# M1 MI8 - Processus d'innovation 2025-2026 # New Page # Diane Lepeu--Cutino # SALBAS Selma Processus d'innovation - Master Management de l'innovation - ### **Première séance du vendredi 16 décembre 2025 :** Dans le cadre de cette UE, nous avons commencé par une séance d’initiation au prototype afin de découvrir les bases de la modélisation 3D et de l’impression. L’objectif de la première séance était de découvrir le FABLAB et les bases de l’impression 3D à travers le logiciel PrusaSlicer et les imprimantes Prusa MK4S. Pour cette toute première impression, j’ai choisi d’imprimer un vase Miffy, à partir d’un fichier STL disponible directement sur le site web printables.com. [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/cOXimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/cOXimage.png) Voici le modèle que j’ai choisi : [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/4cvimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/4cvimage.png) J’ai ensuite importer le fichier STL sur PrusaSlicer dans le but de régler les paramètres tels que la taille du vase et le temps d’impression, puis je l’ai exporter en G code pour débuter l’impression. **Paramètres de l’objet :** [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/Y04image.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/Y04image.png) **Visualisation :** [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/3xiimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/3xiimage.png) Je n’ai malheureusement pas eu le temps d’imprimer ce vase. **Deuxième objet :** J’ai choisi de réaliser le logo d’un chanteur célèbre en impression 3D. Comme pour l'objet précédent, La première étape a consisté à rechercher une image du logo du chanteur. Cette image a ensuite été traitée afin de pouvoir être exploitée en impression 3D. Pour cela, elle a été convertie en modèle 3D au format STL, ce qui permet de transformer une image 2D en un volume imprimable. Cette conversion a nécessité de vérifier la lisibilité du logo et la cohérence des formes afin d’obtenir un rendu correct une fois imprimé. Une fois le fichier STL obtenu, celui-ci a été importé dans le logiciel de tranchage PrusaSlicer. Cette étape est essentielle, car elle permet de préparer le fichier pour l’impression 3D. J’ai alors ajusté différents paramètres tels que : - la hauteur de couche, - le taux de remplissage, - la vitesse d’impression, - ainsi que l’orientation de la pièce sur le plateau. Le fichier G-code généré a été transféré sur l’imprimante 3D Prusa MK4S via une connexion USB. L’impression a ensuite été lancée avec du filament PLA rose. Une fois l’impression terminée, la pièce a été retirée du plateau à l’aide d’une spatule. Voici le logo que j'ai choisis d'imprimer avec ses réglages : [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/xXximage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/xXximage.png)[![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/rtXimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/rtXimage.png) Résultat final : [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/Q4oimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/Q4oimage.png) ### **Deuxième séance du 9 janvier 2026 :** Lors de cette deuxième séance, nous avons découvert le logiciel OpenSCAD. J’ai réalisé un objet imprimé en 3D intégrant un aimant, ce qui représente un niveau de complexité supplémentaire par rapport à une impression classique. L’objet choisi est une forme d’étoile, pensée comme un magnet décoratif pouvant être fixé sur une surface métallique. La conception de l’objet a été réalisée à l’aide du logiciel de modélisation OpenSCAD. Contrairement à un modèle simple, cet objet a nécessité la création de deux volumes distincts : - un volume principal correspondant à la forme extérieure de l’étoile, - et un volume interne destiné à accueillir un aimant rectangulaire. **Code sur OpenSCAD :** [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/3Gtimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/3Gtimage.png) [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/OmJimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/OmJimage.png) [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/Qkximage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/Qkximage.png) Un logement précis a été intégré à l’intérieur de la pièce (visible sur les images). Les dimensions de ce logement ont été volontairement légèrement augmentées afin de prendre en compte les tolérances d’impression, garantissant que l’aimant puisse être inséré facilement sans forcer. Lorsque l’impression a atteint la hauteur correspondant au fond du logement de l’aimant, une pause a été programmée. Cette pause a permis d’insérer manuellement l’aimant dans la cavité prévue à cet effet (au niveau des cercles rouges sur la photo qui suit). L’impression a ensuite été reprise, ce qui a permis de sceller l’aimant à l’intérieur de l’objet, sans ajout de colle. Cette pause à été réalisée à 73% de l'avancement, ce qui correspond a 5/6 minutes d'impression. À ce moment, la cavité prévue pour l'aimant était entièrement formée mais pas encore refermée par la couche supérieure. Une fois l'aimant correctement positionné dans son emplacement prévu, l'impression à été reprise ce qui a permis de refermer la cavité et de sceller l’aimant à l’intérieur de l’objet. Cette méthode permet d’intégrer un élément externe de manière propre et durable, sans nécessiter de collage supplémentaire **État de l'impression au moment de la pause :** [![Capture d’écran 2026-02-15 à 19.11.53.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/capture-decran-2026-02-15-a-19-11-53.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/capture-decran-2026-02-15-a-19-11-53.png) **Résultat :** [![IMG_3724.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/img-3724.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/img-3724.jpeg) [![IMG_3727.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/img-3727.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/img-3727.jpeg) Le projet est réussi : l'aimant adhère bien aux surfaces alimentées comme mon ordinateur sur la photo juste au dessus. L'étoile présente malheureusement quelques défauts comme les pointes qui sont arrondies et non pointues. Cela met en avant les limites normales de l'impression 3D. ### **Prototypage : ( avec Sarah et Mélissa)** La suite des séances avaient pour but de découvrir le prototypage en utilisant les cartes Arduino. Plateforme expérimentale : Arduino Matériel principal : Arduino Uno **1. INTRODUCTION** Cette séance vise l’appropriation d’une plateforme de prototypage microcontrôlée par la mise en œuvre progressive de fonctions fondamentales des systèmes embarqués : génération de sorties numériques, gestion temporelle de l’exécution et interaction capteur–actionneur via acquisition analogique. **Premier prototype :** L’objectif est de mettre en œuvre une sortie logique afin de caractériser la commutation de potentiel sur une broche numérique et sa traduction en signal lumineux. **Dispositif** - Carte Arduino Uno - LED intégrée (broche numérique 13) - Environnement Arduino IDE **Code** void setup() { pinMode(LED\_BUILTIN, OUTPUT); } void loop() { digitalWrite(LED\_BUILTIN, HIGH); delay(1000); digitalWrite(LED\_BUILTIN, LOW); delay(1000); } **Modèle de fonctionnement** La broche associée à LED\_BUILTIN est configurée en sortie. La boucle principale génère une onde carrée de période 2 s par alternance HIGH/LOW, correspondant à une commutation entre ~5 V et 0 V. **Observation** La LED présente un clignotement périodique stable, validant la correspondance entre état logique et émission lumineuse. [![IMG_2881.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/img-2881.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/img-2881.jpeg) **Deuxième prototype :** **Dispositif** - Carte Arduino Uno - Deux LED externes - Deux résistances de limitation de courant - Breadboard **Code** void setup() { pinMode(13, OUTPUT); pinMode(12, OUTPUT); } void loop() { digitalWrite(13, HIGH); delay(2000); digitalWrite(13, LOW); digitalWrite(12, HIGH); delay(1000); digitalWrite(12, LOW); delay(500); } Les deux LED ne clignotent pas de manière indépendante. Le programme exécute les instructions l’une après l’autre à cause de la fonction delay(), ce qui impose un fonctionnement séquentiel. **Observation :** - Le contrôle de plusieurs LED fonctionne correctement. - Les délais bloquent l’exécution du programme pendant leur durée. - Cela montre la limite de cette méthode pour contrôler plusieurs actions en même temps. [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/cxvimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/cxvimage.png) **Prototype 3 :** L’objectif est de mettre en œuvre une chaîne d’acquisition analogique et utiliser une grandeur physique (luminosité) comme variable de décision pour le pilotage d’une LED. **Dispositif** - Carte Arduino Uno - Photo-résistance (LDR) - Résistance de référence (pont diviseur de tension) - LED + résistance - Breadboard **Principe** - Lecture analogique de la tension issue du capteur - Comparaison à un seuil expérimental - Activation ou désactivation de la LED selon la condition lumineuse **Code** int capteur = A0; // entrée analogique de la photorésistance int led = 13; // LED (interne ou externe) int seuil = 500; // seuil de luminosité (à ajuster) void setup() { pinMode(led, OUTPUT); Serial.begin(9600); // pour voir les valeurs mesurées } void loop() { int valeur = analogRead(capteur); // lecture du capteur Serial.println(valeur); if (valeur < seuil) { digitalWrite(led, HIGH); // sombre → LED allumée } else { digitalWrite(led, LOW); // lumineux → LED éteinte } delay(200); } **Observation** La variation d’éclairement modifie continûment la valeur mesurée ; la LED change d’état lorsque le seuil est franchi, établissant une boucle perception–décision–action. [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/P2Yimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/P2Yimage.png) Les résultats obtenus lors de ces exercices mettent en évidence la correspondance entre modèle logiciel et comportement matériel. L’usage de temporisations bloquantes simplifie l’implémentation mais limite l’indépendance temporelle des actionneurs. L’intégration d’un capteur analogique démontre la capacité du système à fermer une boucle de contrôle élémentaire dépendante de l’environnement. # Mariia Karpenko ### **Création d'objets 3D** #### **Etape 1 : faire un objet compliqué pour comprendre l'utilisation de la machine 3D** **16/12/2025** #### **Objectifs :** Imprimer un moule à biscuits en utilisant le modèle existant. #### **Paramètres d'impression utilisés pour cette impression 3D :** Buse : 200°C Plateau : 60°C Diamètre du filament: PLA, 1,75 mm Remplissage : 20 % Paramètres d'impression: paramètres par défaut de PrusaSlicer (qualité standard, épaisseur de couche classique) #### **Logiciels utilisés pour toutes les impressions 3D :** **Slicing** : PrusaSlicer #### **Objet fonctionnel : Moule à biscuits** **Fonction** : Changement de la forme des biscuits **Modèle 3D** : [moule à biscuits](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1607) **Objet sur PrusaSlicer :** [![2026-01-01_16-15-47.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/2026-01-01-16-15-47.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/2026-01-01-16-15-47.png) [![2026-01-01_16-22-15.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/2026-01-01-16-22-15.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/2026-01-01-16-22-15.png) #### **Objet terminé :** [![5384289724211597063.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/5384289724211597063.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/5384289724211597063.jpg) #### **Etape 2 :** **faire un objet compliqué** **16/01/2026 - 30/01/2026** #### **Objectifs :** Imprimer un pyramide avec les trous #### **Paramètres d'impression utilisés pour cette impression 3D :** Buse : PLA Generic Plateau : PLA Generic Diamètre du filament: PLA, 1,75 mm Remplissage : 20 % Paramètres d'impression: support partout avec bordure, paramètres par défaut de PrusaSlicer (qualité standard, épaisseur de couche classique) #### **Logiciels utilisés pour toutes les impressions 3D :** **Slicing** : PrusaSlicer #### **Objet fonctionnel : Pyramide** **Fonction** : Changement de la forme des biscuits **Pyramide 3D** : [Pyramide](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1633) **Code sur OpenSCAD :** ``` $fn = 30; taille_base = 40; hauteur = 35; epaisseur = 3; rayon_sphere = 7; jeu = 0; rayon_loge = 8; profondeur_loge = 4; difference() { // Pyramide extérieure linear_extrude(height = hauteur, scale = 0) square(taille_base, center = true); // Creux intérieur translate([0, 0, epaisseur]) linear_extrude(height = hauteur - epaisseur * 2, scale = 0) square(taille_base - epaisseur * 2, center = true); // Loges sur les côtés for (i = [-1, 1]) { translate([i * (taille_base/4), 0, hauteur/2]) sphere(r = rayon_loge); translate([0, i * (taille_base/4), hauteur/2]) sphere(r = rayon_loge); translate([0, 0, -1]) sphere(r = rayon_loge); } for (i = [-1, 1]) { translate([i * taille_base/2, 0, hauteur/2]) rotate([0, 90, 0]) cylinder(h = epaisseur * 4, r = 4, center = true); translate([0, i * taille_base/2, hauteur/2]) rotate([90, 0, 0]) cylinder(h = epaisseur * 4, r = 4, center = true); translate([0, i * taille_base/2, hauteur/2]) rotate([0, 0, -1]) cylinder(h = epaisseur * 4, r = 4, center = true); } } translate([0, 0, rayon_sphere + jeu]) sphere(r = rayon_sphere); ``` **Objet sur PrusaSlicer :** [![5467371176448430644.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/5467371176448430644.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/5467371176448430644.jpg) [![5467371176448430643.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/5467371176448430643.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/5467371176448430643.jpg) #### **Essais sans résultat :** A chaque tentative j'ai changé les parametres d'impression. Le projet a marché quand j'ai mis les supports + 2 couches de radeau et changé l'imprimante [![5467371176448430600.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/5467371176448430600.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/5467371176448430600.jpg)[![5467371176448430597.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/5467371176448430597.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/5467371176448430597.jpg) #### **Objet terminé :** [![5467371176448430598.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/N5V5467371176448430598.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/N5V5467371176448430598.jpg)[![5467371176448430599.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/rdA5467371176448430599.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/rdA5467371176448430599.jpg) #### **Etape 3 : Utiliser l'Arduino Uno et réaliser des montages** Projet Arduino réalisé avec Angel CHEN visible via ce lien : [Projet Arduino](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1676) # Angel CHEN #### **Informations** - Angel Chen - angel.chen@etu.sorbonne-universite.fr - M1 Management de l'innovation - 09/01/2026 - 01/07/2026 #### **Contexte** Dans le cadre de notre UE Processus d'Innovation, il nous a été demandé de créer un objet en impression 3D pour nous rencontrer avec la CAO via OpenScad. Tout d'abord avec une forme simple, puis une seconde plus complexe (j'ai fais l'inverse car je n'étais pas présent au premier cours). #### **MODÉLISATION COMPLEXE (Fusée Fantaisie)** #### **Objectifs** Modéliser et Imprimer une petite fusée avec un style fantaisiste comme dans les dessins animés. Avec la possibilité de visser la pointe et y ranger des objets. [![Capture d'écran 2026-02-07 à 17.29.55.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/capture-decran-2026-02-07-a-17-29-55.png) ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/capture-decran-2026-02-07-a-17-29-55.png)[![Capture d'écran 2026-02-07 à 17.28.21.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/THecapture-decran-2026-02-07-a-17-28-21.png) ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/THecapture-decran-2026-02-07-a-17-28-21.png)[![Capture d'écran 2026-02-07 à 20.54.23.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/capture-decran-2026-02-07-a-20-54-23.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/capture-decran-2026-02-07-a-20-54-23.png) #### **Matériel** - **Imprimante 3D :** Originale Prusa MK4S - **Filament** : PLA #### **Machines utilisées** - **Logiciel de montage : ** OpenSCAD - **Logiciel de découpe** : PrusaSlicer #### **Construction** - ##### **Le Code** Tout d'abord mon code : J'ai d'abord créer les formes que je voulais séparément et puis je les ai assemblées. J'ai donc joué sur l'échelle et la position de chaque morceaux, d'où la forme de mon code. ```openSCAD // Changement de la résolution du modèle $fa = 1; $fs = 0.4; $fn = 200; //forme de la vis module vis_simple(diametre=10, longueur=30, pas=5) { rayon = diametre / 2; nb_tours = longueur / pas; union() { //L'axe central cylinder(r=rayon - 1, h=longueur); //Le filetage linear_extrude(height=longueur, twist=-360 * nb_tours) translate([rayon - 1.5, 0, 0]) circle(r=1.5, $fn=30); } } //Nez de la fusée module nez() { color("Red") //permet d'avoir le nez au dessus de la fusée translate([0, 0, 58]) // translate([0, 35, 9.8]) difference() { union() { // Le Haut (Cône + Antenne) cylinder(h=15.1, r1=5.8, r2=0.7); translate([0, 0, 15]) cylinder(h=4, r=0.7); translate([0, 0, 19]) sphere(r=1); // Le Bas (La vis) rotate([180, 0, 0]) vis_simple(diametre=9.4, longueur=9.8, pas=4); } //Trou rotate([180, 0, 0]) translate([0, 0, -1]) cylinder(h=20, r=3); } } nez(); // Corps de la fusée module fuselage() { color("White") union() { hull() { //Diamètre 1 (base au sol) translate([0, 0, 0]) cylinder(h=0.1, d=15); //Diamètre 2 (intersection) translate([0, 0, 15]) cylinder(h=0.1, d=20); //Création du haut du fuselatge qui est arrondi difference() { scale([0.69, 0.69, 4]) sphere(r=15); translate([-50, -50, 50]) cube([100, 100, 100]); translate([-50, -50, 15 - 100]) cube([100, 100, 100]); } } } } module trou(){ difference(){ fuselage(); union() { translate([0, 0, 40]) vis_simple(diametre=10, longueur=11, pas=4); translate([0, 0, 0]) cylinder(h=40.1, d=8); } } } module hublot() { translate([7.3, 0, 35]) rotate([0, 83, 0]) { //Le cadre gris color("Gray") rotate_extrude() translate([4, 0, 0]) circle(r=1.5); //La vitre bleue color("DodgerBlue") scale([1, 1, 0.5]) sphere(r=4); } } module ailerons() { color("Red") //On répète 3 fois autour de l'axe for(i = [60 : 120 : 360]) { rotate([0, 0, i]) translate([8, 0, 10]) rotate([90, 0, 0]) // On met à plat verticalement linear_extrude(height=3, center=true) //Pour la forme polygon(points=[ [0, -6], [2, 5], [10, 0], [14, -18], [10, -18] ]); } } module moteur() { translate([0,0,-10.3]) scale([0.86,0.86,0.86]) union(){ //Bague métalique color("Silver") translate([0, 0, 12]) difference() { // Forme extérieure arrondie rotate_extrude() translate([6, 0, 0]) // Rayon de l'anneau circle(r=2.5); translate([0, 0, 2.6]) cube([20, 20, 5], center=true); } //Tuyère color("#333333") // Gris très foncé translate([0, 0, 5]) difference() { cylinder(h=7.1, r1=8, r2=5); translate([0, 0, -1]) cylinder(h=5, r1=6, r2=4); } //anneau bas de la tuyère color("#222222") rotate_extrude() translate([8, 5, 0]) circle(r=1); } } translate([0,0,8]) union(){ trou(); hublot(); ailerons(); moteur(); } ``` - ##### **Réglages d'impression** - **Hauteur de couche :** 0,2 mm (SPEED) - **Remplissage :** 20 % - **Température de la buse :** 215 °C (première couche) | 210°C (autres canapés) - **Température du plateau :** 65 °C (première et autres canapés) - **Vitesse d'impression :** paramètres par défaut de PrusaSlicer - **Supports :** Support sur plateau uniquement - **Adhérence au plateau :** par défaut [![Capture d'écran 2026-01-30 à 15.46.40.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/capture-decran-2026-01-30-a-15-46-40.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/capture-decran-2026-01-30-a-15-46-40.png) - ##### **Étapes de réalisation** 1. 1. Recherche et récupération du fichier STL - Vérifier l'échelle du modèle (Ici l'échelle est de 120%) - Vérifier l'orientation et la position sur le plateau 2. Importation du fichier STL dans PrusaSlicer - Normes de vérification des réglages - Ajustement si nécessaire 3. Génération du G-code 4. Lancement de l'impression 3D 5. Observation de la formation des couches et suivi du retour. - Surveiller la première couche - ##### **Observations et anecdotes**
Après l'impression, le diamètre du nez ou l'épaisseur de feuilletage de la vis du nez est sans doute trop grande car elle grippe lorsque j'ai essayé de visser le nez.
- ##### **Résultat**
Voici le résultat de cette impression : [![Capture d'écran 2026-02-07 à 21.26.41.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/capture-decran-2026-02-07-a-21-26-41.png) ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/capture-decran-2026-02-07-a-21-26-41.png)[![Capture d'écran 2026-02-07 à 21.32.19.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/capture-decran-2026-02-07-a-21-32-19.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/capture-decran-2026-02-07-a-21-32-19.png) \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ #### **MODÉLISATION SIMPLE (Support pour Fusée Fantaisie)** #### **Objectifs** Pour mettre en valeur ma fusée précédemment imprimée, j'ai décidé de faire un support qui me permettra d'exposer la fusée ! [![Capture d'écran 2026-02-07 à 20.20.14.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/HNPcapture-decran-2026-02-07-a-20-20-14.png) .](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/HNPcapture-decran-2026-02-07-a-20-20-14.png)[![Capture d'écran 2026-02-07 à 20.20.37.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/capture-decran-2026-02-07-a-20-20-37.png) ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/capture-decran-2026-02-07-a-20-20-37.png)[![Capture d'écran 2026-02-07 à 20.19.05.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/capture-decran-2026-02-07-a-20-19-05.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/capture-decran-2026-02-07-a-20-19-05.png) #### **Matériel** - **Imprimante 3D :** Originale Prusa MK4S - **Filament** : PLA #### **Machines utilisées** - **Logiciel de montage : ** OpenSCAD - **Logiciel de découpe** : PrusaSlicer #### **Construction** - ##### **Le Code** Tout d'abord mon code : J'ai d'abord créer les formes que je voulais séparément et puis je les ai assemblées. J'ai donc joué sur la position de chaque morceaux, d'où la forme de mon code. ```openSCAD // Changement de la résolution du modèle $fa = 1; $fs = 0.4; $fn = 200; //Support fusee //Paramètre du Socle longueur = 80; largeur = 50; hauteur_totale = 8; rayon_arrondi = 12; //Arrondi du Socle module socle_arrondi(l, w, h, r) { hull() { translate([-(l/2)+r, -(w/2)+r, 0]) cylinder(h=h, r=r); translate([(l/2)-r, -(w/2)+r, 0]) cylinder(h=h, r=r); translate([-(l/2)+r, (w/2)-r, 0]) cylinder(h=h, r=r); translate([(l/2)-r, (w/2)-r, 0]) cylinder(h=h, r=r); } } //Création du Socle module Socle(){ difference() { union() { //Niveau 1 : La base socle_arrondi(longueur, largeur, hauteur_totale * 0.6, rayon_arrondi); //Niveau 2 : Le plateau supérieur translate([0, 0, hauteur_totale * 0.6]) socle_arrondi(longueur - 10, largeur - 10, hauteur_totale * 0.4, rayon_arrondi - 5); } } } //Bras de support module Bras(){ rayon_arc = 20; // Courbure angle_max = 140; // Jusqu'ou monte le bras translate([30,0,27.6]) rotate([90,0,0]) cylinder(h = 6, d = 6, center = true); translate([15, 0, -8]) union() { for (a = [0 : 1 : angle_max]) { x = rayon_arc * sin(a); z = rayon_arc - (rayon_arc * cos(a)); translate([x, 0, z]) rotate([0, a, 0]) rotate([90, 0, 0]) cylinder(h = 6, d = 6, center = true); } } //Socle du Bras translate([20, 0, -8]) cube([30, 20, 2], center = true); } module fuselage() { color("White") union() { hull() { //Diamètre 1 (base au sol) translate([0, 0, 0]) cylinder(h=0.1, d=15); //Diamètre 2 (intersection) translate([0, 0, 15]) cylinder(h=0.1, d=20); //Création du haut du fuselatge qui est arrondi difference() { scale([0.69, 0.69, 4]) sphere(r=15); translate([-50, -50, 50]) cube([100, 100, 100]); translate([-50, -50, 15 - 100]) cube([100, 100, 100]); } } } } module ailerons() { color("Red") //On répète 3 fois autour de l'axe for(i = [60 : 120 : 360]) { rotate([0, 0, i]) translate([8, 0, 10]) rotate([90, 0, 0]) // On met à plat verticalement linear_extrude(height=3, center=true) //Pour la forme polygon(points=[ [0, -6], [2, 5], [10, 0], [14, -18], [10, -18] ]); } } //Pince à fusée module Pince(){ translate([-4,0,56.15]) rotate([0,80,0]) difference() { //Le corps de la pince cylinder(h = 15, d = 23, center = true); //Le trou pour la fusee translate([-95,-50,-20]) cube([100,100,100]); translate([0,0,-15]) fuselage(); translate([0,0,-15]) ailerons(); } } union(){ color("Grey") Socle(); color("Grey") translate([-30,0,16]) Bras(); color("Grey") Pince(); } ``` - ##### **Réglages d'impression** - **Hauteur de couche :** 0,2 mm (SPEED) - **Remplissage :** 20 % - **Température de la buse :** 215 °C (première couche) | 210°C (autres canapés) - **Température du plateau :** 65 °C (première et autres canapés) - **Vitesse d'impression :** paramètres par défaut de PrusaSlicer - **Supports :** Support sur plateau uniquement - **Adhérence au plateau :** par défaut [![Capture d’écran 2026-02-18 à 19.50.49.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/capture-decran-2026-02-18-a-19-50-49.png). ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/capture-decran-2026-02-18-a-19-50-49.png)[![Capture d’écran 2026-02-18 à 19.52.14.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/capture-decran-2026-02-18-a-19-52-14.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/capture-decran-2026-02-18-a-19-52-14.png) Pour bien imprimer la pièce, j'ai ajouté des supports partout car il y a un point de faiblesse qui ne m'aurait pas permis d'imprimer correctement. - ##### **Étapes de réalisation** 1. 1. Recherche et récupération du fichier STL - Vérifier l'échelle du modèle (Ici l'échelle est de 120%) - Vérifier l'orientation et la position sur le plateau 2. Importation du fichier STL dans PrusaSlicer - Normes de vérification des réglages - Ajustement si nécessaire 3. Génération du G-code 4. Lancement de l'impression 3D 5. Observation de la formation des couches et suivi du retour. - Surveiller la première couche
- ##### **Résultat**
Voici le résultat de cette impression : [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/6OZimage.png). ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/6OZimage.png)[![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/Duaimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/Duaimage.png) Le résultat final : [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/fRzimage.png). ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/fRzimage.png)[![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/gTmimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/gTmimage.png) \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ #### **PROJET Arduino** **Réalisé avec Mariia KARPENKO visible via ce lien : [Projet Arduino](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1675)**
# ZEGHOUDI Salma **Mardi 16 décembre 2026** ### **Activité Impression 3D** ### Cœur prénom « Zakia »
1. Objectif de l'activité
L'objectif de cette séance était de découvrir les bases de l'impression 3D à travers un projet simple et personnalisé. Contrairement à l'utilisation d'un fichier STL existant, ici la modélisation a été réalisée directement avec OpenSCAD, ce qui a permis d'aborder à la fois la modélisation paramétrique et le processus complet d'impression 3D.
2. Description de l'activité
Le projet consiste à modéliser et imprimer un cœur 3D personnalisé avec le prénom « Zakia » en relief sur la face supérieure. Cet objet a été entièrement conçu dans OpenSCAD à l'aide d'une formule mathématique paramétrique, puis tranché avec PrusaSlicer avant d'être imprimé en PLA rouge. Ce type d'objet est idéal pour une première approche car il est :
- Rapide à imprimer (petit volume) - Visuellement parlant : on observe bien la construction couche par couche - Personnalisable facilement via les paramètres OpenSCAD
3. Matériel utilisé
ÉlémentDétail
Imprimante 3DOriginal Prusa MK4S
FilamentPLA Rouge
Logiciel de modélisationOpenSCAD
SlicerPrusaSlicer
4.logiciels **OpenSCAD : Modélisation** OpenSCAD est un logiciel de modélisation 3D paramétrique. Il fonctionne entièrement par script : on décrit la forme avec du code, ce qui permet une personnalisation facile et reproductible. Le code utilisé repose sur une courbe mathématique paramétrique (formule du cœur) et intègre le prénom en relief via la fonction `text()`. **PrusaSlicer :Tranchage** PrusaSlicer est le logiciel de tranchage utilisé pour préparer le fichier d'impression. Il convertit le modèle 3D (fichier STL exporté depuis OpenSCAD) en instructions G-code compréhensibles par l'imprimante.
5. Code OpenSCAD utilisé
[![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/t4Wimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/t4Wimage.png)
6. Réglages d'impression
ParamètreValeur
MatériauPLA Rouge
Hauteur de couche0,15 mm (SPEED)
Remplissage20 %
Température buse200 °C
Température plateau60 °C
VitesseParamètres par défaut PrusaSlicer
SupportsNon
Adhérence plateauPar défaut (brim si nécessaire)
7. Étapes de réalisation
1. **Modélisation dans OpenSCAD** - Écriture du code paramétrique (courbe mathématique du cœur) - Ajout du texte « Zakia » en relief avec la fonction `text()` - Aperçu via Design → Preview, puis rendu via Design → Render - Export du fichier STL : File → Export → Export as STL 2. **Importation dans PrusaSlicer** - Vérification de l'échelle et de l'orientation sur le plateau - Vérification des réglages standards - Ajustement si nécessaire (rotation, mise à l'échelle) 3. **Génération du G-code** - Lancement du tranchage dans PrusaSlicer - Vérification de l'aperçu des couches 4. **Impression 3D** - Lancement de l'impression sur la Prusa MK4S - Surveillance de la première couche - Suivi du déroulement et observation de la formation des couches
8. Observations et anecdotes > « C'était fascinant de voir le texte en relief apparaître progressivement, couche après couche et la forme du cœur prenait vie devant mes yeux. » Points d'attention observés lors de l'impression :
- La première couche est critique : une mauvaise adhérence peut compromettre toute l'impression. - Le relief du texte (1,5 mm) est suffisant pour être lisible sans fragiliser la pièce. 9. Résultat
Le cœur imprimé est conforme au modèle conçu dans OpenSCAD. Le prénom « Zakia » est bien lisible en relief sur la face supérieure. La couleur rouge du PLA donne à l'objet un rendu esthétique fidèle à l'objet de référence.
- Dimensions respectées et forme du cœur bien symétrique - Texte en relief net et lisible - Surface propre sans défaut majeur visible [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/5Q7image.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/5Q7image.png)[![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/w8Uimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/w8Uimage.png)
10. Limites
- La police disponible dans OpenSCAD peut varier selon le système, ce qui peut affecter le rendu du texte. - Les réglages avancés de PrusaSlicer n'ont pas été explorés. - Le projet ne permet pas d'évaluer la résistance mécanique de la pièce. - L'impression a été réalisée uniquement en PLA rouge, sans comparaison avec d'autres matériaux.
## Sifflet fonctionnel 1. Objectif du projet L'objectif de cette séance était d'aller plus loin dans la pratique de l'impression 3D en modélisant from scratch un objet fonctionnel : un sifflet. Contrairement à la séance précédente (cœur Zakia), ce projet introduit des notions plus avancées de modélisation OpenSCAD (différences booléennes, biseau acoustique) et tente une manipulation plus complexe pendant l'impression. 2. Description du projet Le projet consiste à modéliser et imprimer un sifflet fonctionnel entièrement conçu dans OpenSCAD. L'objet comprend un corps creux, un embout buccal, un biseau (fipple) générateur de son, et un anneau d'accroche porte-clé. Une tentative originale a été faite : **mettre l'impression en pause** pour introduire manuellement une petite bille à l'intérieur du corps, afin d'obtenir un sifflet à bille comme les modèles classiques. Cette manipulation n'a malheureusement pas fonctionné comme prévu. 3. Matériel utilisé
ÉlémentDétail
Imprimante 3DOriginal Prusa MK4S
FilamentPLA Blanc
Logiciel de modélisationOpenSCAD
SlicerPrusaSlicer
Élément supplémentaireBille (tentative d'insertion manuelle)
4. Logiciels utilisés **OpenSCAD et PrusaSlicer : Tranchage** PrusaSlicer a été utilisé pour trancher le modèle et tenter de gérer la pause d'impression via la fonction **"Pause at layer"**, dans le but d'insérer une bille manuellement entre deux couches. 5. Code OpenSCAD utilisé // ============================================================ // SIFFLET CLASSIQUE TYPE ARBITRE // ============================================================ $fn = 100; // CORPS PRINCIPAL (forme ovale aplatie) module corps() { difference() { // Coque extérieure ovale scale(\[1, 0.65, 1\]) sphere(r=18); // Vider l'intérieur scale(\[1, 0.65, 1\]) sphere(r=15.5); // Couper le bas plat translate(\[0, 0, -30\]) cube(\[60, 60, 30\], center=true); // Couper l'avant pour raccorder l'embout translate(\[22, 0, 0\]) cube(\[20, 40, 40\], center=true); // Couper l'arrière translate(\[-22, 0, 0\]) cube(\[20, 40, 40\], center=true); // Fente sonore sur le dessus translate(\[-5, -20, 6\]) cube(\[10, 40, 2\]); } } // EMBOUT BUCCAL module embout() { translate(\[18, 0, 1\]) rotate(\[0, 90, 0\]) difference() { union() { cylinder(r1=5, r2=4, h=14); translate(\[0, 0, 14\]) cylinder(r=4, h=3); } cylinder(r1=3.5, r2=2.8, h=18); } } // CHAMBRE ARRIERE FERMEE module fond\_arriere() { translate(\[-18, 0, 1\]) rotate(\[0, -90, 0\]) difference() { cylinder(r=10, h=4); cylinder(r=8.5, h=4); } } // ANNEAU DE CORDON module anneau() { translate(\[-20, 0, 8\]) rotate(\[90, 0, 0\]) difference() { torus\_shape(6, 2.2); // Support de l'anneau sur le corps } } module torus\_shape(R, r) { rotate\_extrude() translate(\[R, 0, 0\]) circle(r=r); } // BILLE INTERNE (visible si coupe) module bille() { translate(\[0, 0, 2\]) sphere(r=5); } // PLAQUE DE SIFFLET (languette sonore) module languette() { translate(\[-8, -15.5, 0\]) cube(\[16, 1.5, 6\]); } // ============================================================ // ASSEMBLAGE FINAL // ============================================================ union() { corps(); embout(); fond\_arriere(); anneau(); languette(); } 6.Réglages d'impressions
ParamètreValeur
MatériauPLA Blanc
Hauteur de couche0,15 mm (SPEED)
Remplissage100 %
Température buse200 °C
Température plateau60 °C
VitesseParamètres par défaut PrusaSlicer
SupportsNon
Adhérence plateauPar défaut
Pause à la coucheTentative d'insertion de bille
7. Étapes de réalisation 1. **Modélisation dans OpenSCAD** - Écriture du code paramétrique (corps, embout, fipple, anneau) - Utilisation de `hull()` et `difference()` pour la forme creuse - Aperçu via Design → Preview, rendu via Design → Render - Export STL : File → Export → Export as STL 2. **Importation dans PrusaSlicer** - Vérification de l'orientation (embout face à gauche, biseau sur le dessus) - Réglage du remplissage à 100 % pour assurer l'étanchéité acoustique - Ajout d'une **pause à une couche intermédiaire** pour l'insertion de la bille 3. **Génération du G-code** - Tranchage avec pause programmée - Vérification de l'aperçu des couches et de la position de la pause 4. **Impression 3D** - Lancement de l'impression sur la Prusa MK4S - Surveillance de la première couche - À la couche de pause : tentative d'insertion manuelle de la bille 5. **Tentative d'insertion de la bille** - Mise en pause de l'imprimante à mi-hauteur - Introduction d'une bille dans la cavité interne - Reprise de l'impression : résultat non concluant (voir Observations) 8. Observations et anecdotes > « L'idée d'insérer une bille pendant l'impression semblait simple en théorie mais en pratique, la cavité n'était pas encore assez ouverte à la couche de pause choisie, et la bille n'a pas pu être correctement positionnée. » Points d'attention observés : - La **couche de pause** a été choisie trop tôt : la cavité intérieure n'était pas encore suffisamment formée pour accueillir la bille dans la bonne position. - La bille, une fois la buse revenue, a été **partiellement écrasée ou déplacée** par le filament des couches suivantes. - Le biseau (fipple) est fonctionnel mais le son produit est faible — probablement lié à un léger manque d'étanchéité des parois à 0,15 mm de couche. - L'anneau porte-clé est bien formé et solide. 9. Résultat [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/fEbimage.png) ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/fEbimage.png)[![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/iFKimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/iFKimage.png) Le sifflet imprimé est globalement conforme au modèle OpenSCAD, comme on peut le constater visuellement : - Le corps est bien formé, les parois sont propres - L'embout buccal et l'anneau porte-clé sont correctement imprimés - Le biseau (ouverture rectangulaire sur le dessus) est bien visible - La tentative d'insertion de bille n'a pas abouti : le sifflet fonctionne sans bille mais avec un son moins puissant qu'un sifflet à bille classique 10. Limites du projet - La **pause d'impression pour insertion de bille** nécessite une planification précise de la couche de pause — à retravailler. - Le diamètre de la cavité interne doit être **adapté exactement** au diamètre de la bille choisie avant l'impression. - Le remplissage à 100 % rallonge significativement le temps d'impression. - La qualité acoustique du sifflet dépend fortement de la précision du biseau, difficile à obtenir à 0,15 mm de couche. 11.Apprentissage **Impression 3D :** - Utilisation de la fonction **"Pause at layer"** dans PrusaSlicer - Importance du choix de la **bonne couche de pause** pour les insertions - Impact du remplissage à 100 % sur l'étanchéité et le temps d'impression - Un projet raté est aussi un apprentissage : identifier pourquoi ça n'a pas fonctionné est aussi important que réussir ! ## EXERCICE ARDUINO ( avec lila Yahiaoui ) ##### Contexte : Dans le cadre de l'UE "Processus d'Innovation", nous nous initions à l'électronique afin d'imaginer et de concevoir le prototype de service innovant. Objectif : Découvrir et prendre en main le logiciel Arduino à travers des manipulations concrètes, portant sur le contrôle de l'allumage de LEDs, la gestion de leur intensité lumineuse, ainsi que la programmation d'alternances entre états allumé et éteint. **Qu'est ce Arduino ?** Arduino est un outil composé d'une carte électronique programmable et d'un logiciel permettant de lui envoyer des instructions pour contrôler des composants comme des LEDs ou des capteurs. Il utilise un langage simple basé sur le C/C++, accessible même aux débutants. C'est l'outil idéal pour prototyper rapidement des idées innovantes. 1.Notre objectif dans un premier temps est de faire cllignoter la Led
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
}
[![WhatsApp Image 2026-04-10 at 16.41.56.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/scaled-1680-/whatsapp-image-2026-04-10-at-16-41-56.jpeg) ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/whatsapp-image-2026-04-10-at-16-41-56.jpeg)[![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/pFDimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/pFDimage.png) Un code basique permettant de faire clignoter une LED en définissant une durée d'allumage et une durée d'extinction. 2\. Programmer deux LEDs pour qu'elles clignotent à des fréquences distinctes.
void setup() {
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
}
void loop() {
digitalWrite(13, HIGH);
delay(2000);
digitalWrite(13, LOW);
digitalWrite(12, HIGH);
delay(1000);
digitalWrite(12, LOW);
delay(500);
}
[![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/Imrimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/Imrimage.png)[![SQCimage.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/sqcimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/sqcimage.png) [ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/whatsapp-image-2026-04-10-at-16-51-56.jpeg) Chaque LED possède ses propres durées d'allumage et d'extinction, permettant de régler indépendamment le rythme de clignotement de chacune, sans qu'elles soient forcément liées l'une à l'autre. ##### 3.
// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(LED_BUILTIN, OUTPUT);
pinMode(12, OUTPUT);
Serial.begin(9600);
}
// the loop function runs over and over again forever
void loop() {
/*digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(12, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
digitalWrite(12, HIGH); // turn the LED off by making the voltage LOW
delay(1000);
digitalWrite(LED_BUILTIN, LOW);
delay(1000); */ // wait for a second
// read the input on analog pin 0:
int sensorValue = analogRead(A0);
// Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V):
float voltage = sensorValue * (5.0 / 1023.0);
// print out the value you read:
Serial.println(voltage);
if (voltage > 4){
digitalWrite(LED_BUILTIN, HIGH);
digitalWrite(12, LOW);
} else{
digitalWrite(LED_BUILTIN, LOW);
digitalWrite(12, HIGH);
}
}
Cette activité m'a permis de découvrir les **bases de la programmation Arduino** et de comprendre comment contrôler des composants électroniques tels que les LEDs. La principale **difficulté** rencontrée a été la gestion simultanée de plusieurs LEDs avec des rythmes indépendants, ce qui a nécessité une meilleure organisation du code. La **limite** de cet exercice reste sa simplicité — on ne fait que contrôler des LEDs, ce qui est encore loin de la complexité d'un vrai prototype. Cette activité est néanmoins un **premier pas concret** vers la conception de notre projet innovant, en nous donnant les bases pour envisager l'intégration de capteurs ou d'autres composants plus avancés [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/zOiimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/zOiimage.png) # Lila Yahiaoui ##### **1er séance :** Découverte du fablab ainsi que des logiciels OpenSCAD et PrusaSlicer. ##### **2ème séance : IMPRESSION OBJET 3D** Objectif : Nous avons commencé à imprimer nos projets. J’ai choisi un modèle déjà prêt et je lui ai apporté des modifications. J’ai modifié le code en ajoutant mon prénom «INES», j’ai ajouté un cœur sur une des faces du cube et j’ai changé la couleur en « black ». Voici le script utilisé : [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/YbYimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/YbYimage.png) [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/6Tximage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/6Tximage.png)[![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/12oimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/12oimage.png) [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/scaled-1680-/Gb2image.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/Gb2image.png) **2ème objet : Porte clé** [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/0zximage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/0zximage.png) [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/scaled-1680-/FQYimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/FQYimage.png)[![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/scaled-1680-/ljZimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/ljZimage.png) **3ème objet : Hello Kitty** [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/BUDimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/BUDimage.png) [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/qCgimage.png) ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/qCgimage.png) [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/5kCimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/5kCimage.png) **Activité Arduino :** Arduino donne une avoir une aide intelligence à des objets que l'on peut fabriquer [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/scaled-1680-/lAHimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/lAHimage.png)[![fc1image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/scaled-1680-/jYpfc1image.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/jYpfc1image.png) Code : [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/scaled-1680-/s6Eimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/s6Eimage.png) J'ai réalisé le clignotement d'une LED via l'application TinkerCAD # Elio Antoun - Wiki Prototypage ## Séance 1 — Découverte de l'impression 3D ### 1. Objectif de la séance L'objectif de cette première séance était de découvrir le fonctionnement de l'impression 3D à travers : - la recherche d'un modèle existant, - son importation dans un logiciel de tranchage (slicer), - le choix de paramètres d'impression adaptés, - et la préparation du fichier pour l'impression. ### 2. Recherche d'un modèle 3D Dans un premier temps, j'ai effectué une recherche sur le web afin de trouver une base de données de modèles 3D prêts à imprimer. Je me suis orienté vers la plateforme **Printables.com**, qui regroupe des milliers de modèles partagés par la communauté. [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/bDbimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/bDbimage.png) Après avoir exploré plusieurs catégories, j'ai choisi de me concentrer sur des figurines, car elles permettent de tester à la fois : les détails, les volumes, et la stabilité à l'impression. C'est dans ce cadre que j'ai sélectionné le modèle **« Minecraft Baby Creeper »**, conçu par l'utilisateur Shark Byte. Ce choix s'explique par : - sa forme simple mais détaillée, - sa taille réduite, - son aspect ludique, idéal pour une première prise en main. [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/n8yimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/n8yimage.png) ### 3. Importation dans le slicer Le fichier STL du Baby Creeper a été téléchargé depuis Printables puis importé dans le logiciel PrusaSlicer. Une fois le modèle chargé : - il a été automatiquement positionné sur le plateau, - ses dimensions ont été vérifiées, - son orientation n'a pas été modifiée afin de conserver sa stabilité. Dimensions globales du modèle : - X : 114,41 mm - Y : 100,69 mm - Z : 24 mm ### [ ![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/OCBimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/OCBimage.png)[![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/qSXimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/qSXimage.png) ### 4. Choix des réglages d'impression L'objectif était d'obtenir une figurine suffisamment robuste, avec un temps d'impression raisonnable. Les réglages suivants ont été sélectionnés :
ParamètreValeur
Profil0.15 mm SPEED
FilamentGeneric PLA (vert)
ImprimanteOriginal Prusa MK4S HF — buse 0.4 mm
SupportsSeulement pour les générateurs de supports
Remplissage15 %
Bordure (brim)Désactivée
### 5. Résultat ![IMG_7308.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/img-7308.jpeg) *Légende : Le « Minecraft Baby Creeper » imprimé en PLA vert. Les détails du visage (yeux, bouche) sont nets malgré la taille réduite, et la figurine tient parfaitement debout sur ses deux pieds.* ### 6. Conclusion de la séance Cette séance m'a permis de comprendre le rôle d'un slicer, manipuler un modèle 3D, choisir des paramètres adaptés, et préparer un fichier pour l'impression. Elle constitue une première étape essentielle avant de passer à des objets plus complexes et à des conceptions originales lors des séances suivantes. --- ## Séance 2 — Conception d'un objet impossible par fabrication traditionnelle ### 1. Objectif de la séance L'objectif de cette deuxième séance était de concevoir un objet dont la fabrication est impossible avec des procédés traditionnels, et qui nécessite obligatoirement l'impression 3D. Contrairement à la séance 1 (basée sur un modèle existant), cette séance repose sur la création d'un objet original intégrant une géométrie interne non accessible. ### 2. Principe de l'objet L'objet conçu est une cage sphérique contenant une boule libre à l'intérieur, imprimée en une seule pièce. [ ![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/BU4image.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/BU4image.png) Caractéristiques principales : - La boule interne est totalement enfermée. - Elle peut bouger librement dans la cage. - Il est impossible de l'assembler après fabrication, car aucune ouverture ne permet d'insérer la sphère. Ce type de géométrie ne peut pas être produit par : - **usinage** (outil non accessible), - **moulage** (contre-dépouilles internes), - **assemblage** (aucune ouverture). → Il s'agit donc d'un objet **exclusivement réalisable par fabrication additive**. ### 3. Outil de modélisation Le modèle a été conçu avec le logiciel OpenSCAD, qui permet de créer des formes paramétriques à partir de code. Les paramètres principaux définis sont : - le diamètre de la sphère intérieure, - l'épaisseur de la cage, - le jeu entre les deux éléments, - la résolution d'affichage. ```c // Paramètres $fn = 60; // Résolution (augmente à 100 pour une finition plus lisse) diametre_interieur = 20; epaisseur_cage = 3; espace_jeu = 2; // L'espace pour que la boule bouge librement // 1. La sphère intérieure (libre) sphere(d = diametre_interieur); // 2. La cage extérieure difference() { sphere(d = diametre_interieur + (epaisseur_cage * 2) + (espace_jeu * 2)); sphere(d = diametre_interieur + (espace_jeu * 2)); rotate([0, 90, 0]) cylinder(h = 100, d = 15, center = true); rotate([90, 0, 0]) cylinder(h = 100, d = 15, center = true); cylinder(h = 100, d = 15, center = true); } ``` ### 4. Description du modèle Le modèle est composé de : - **Une sphère interne libre**, qui représente l'élément mobile. - **Une cage sphérique externe**, évidée à l'intérieur pour laisser la place à la boule. - **Trois ouvertures cylindriques** orientées sur les axes X, Y et Z, permettant de voir la boule, de prouver qu'elle est enfermée, sans permettre son extraction. ### 5. Itérations d'impression — les trois tentatives L'impression de cet objet s'est révélée beaucoup plus complexe qu'anticipé. La géométrie intérieure flottante (boule libre maintenue uniquement par sa cage) impose à l'imprimante de réaliser des **bridges** (ponts) sur de longues distances et de gérer des **overhangs** importants au sommet de la sphère externe. Trois tentatives ont été nécessaires avant d'obtenir un résultat satisfaisant. #### Tentative n°1 — Échec (PLA blanc) [ ![IMG_8268.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/img-8268.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/img-8268.jpeg)[![IMG_8269.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/img-8269.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/img-8269.jpeg) *Légende : Première tentative — la voûte supérieure de la cage s'est effondrée, et l'on observe nettement les filaments qui partent en « spaghetti » au sommet. La boule interne reste en partie soudée à la paroi de la cage à cause des supports résiduels.* **Diagnostic du problème :** - **Effondrement du sommet** : l'overhang de la sphère externe a dépassé l'angle critique (>50°) sur les dernières couches, ce qui a provoqué le décrochage du filament. - **Cooling insuffisant** : les couches supérieures n'avaient pas le temps de durcir avant que la suivante ne soit posée. - **Vitesse trop élevée** sur les couches sphériques, ce qui a accentué l'oscillation de la tête d'impression. - **Boule soudée** : sans assez d'espace de jeu, la boule interne s'est partiellement fusionnée à la cage extérieure. #### Tentative n°2 — Échec partiel (PLA orange) [ ![IMG_8270.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/img-8270.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/img-8270.jpeg)[![IMG_8017.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/img-8017.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/img-8017.jpeg) *Légende : Deuxième tentative — la forme générale tient mieux mais le sommet présente toujours un défaut visible (anneau aplati), et la cage est plus écrasée que sphérique. La boule interne reste mal détachée.* **Ajustements appliqués après la tentative n°1 :** - Augmentation du **jeu (espace\_jeu)** de 2 mm à 2,5 mm pour mieux désolidariser la boule de la cage. - **Vitesse d'impression** réduite à 60 % sur les overhangs supérieurs. - **Cooling** activé à 100 % dès la couche n°5. **Problèmes restants :** - Le sommet reste fragile car la sphère externe est trop fine (epaisseur\_cage = 3 mm) — l'imprimante n'a pas assez de matière pour stabiliser la voûte. - La forme s'aplatit sur le dessus à cause d'un **cumul de chaleur** local. #### Tentative n°3 — Succès (PLA vert foncé) [ ![IMG_8267.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/img-8267.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/img-8267.jpeg) *Légende : Troisième tentative — la cage sphérique est cette fois parfaitement formée, les ouvertures sont nettes, et la boule interne se déplace librement à l'intérieur sans aucun point de contact permanent. La boule interne est parfaitement isolée et mobile. La cage présente quatre ouvertures permettant d'observer la sphère interne sous différents angles. Cet objet illustre parfaitement la spécificité de l'impression 3D : aucune autre méthode de fabrication ne permettrait de réaliser une telle pièce en monobloc.* **Ajustements finaux décisifs :** - **Épaisseur de la cage** portée de 3 mm à 4 mm → la voûte supérieure tient mieux son propre poids. - **Augmentation de $fn à 100** pour lisser la sphère et réduire les angles vifs propices au décrochage. - **Brim de 5 mm** pour une meilleure adhérence au plateau. - Réorientation du modèle de façon à minimiser l'angle d'overhang maximal. - Petite réduction du diamètre des ouvertures cylindriques (d = 13 au lieu de 15) pour préserver davantage de matière au sommet. [ ![IMG_8271.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/img-8271.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/img-8271.jpeg) *Légende : Comparaison des trois tentatives. À gauche : tentative n°1 (blanc, effondrée). Au centre : tentative n°2 (orange, déformée). À droite : tentative n°3 (verte, réussie). On observe clairement la progression de la qualité d'impression et la maîtrise progressive des paramètres.* ### 6. Retours d'expérience Cette séance a été particulièrement formatrice car elle a confronté la **théorie de la modélisation paramétrique** à la **réalité physique de l'impression FDM**. Les enseignements clés : 1. **Tout n'est pas imprimable « tel quel »** : un modèle qui s'affiche correctement à l'écran peut très bien échouer en impression à cause de contraintes physiques (gravité, refroidissement, cohésion). 2. **Les paramètres du slicer sont aussi importants que la modélisation** : la moitié des problèmes ont été résolus côté slicer (vitesse, cooling, brim), pas côté code. 3. **L'itération est centrale** : le seul moyen d'optimiser un design innovant en impression 3D est de **prototyper, observer, ajuster**. ### 7. Conclusion Cette séance m'a permis de passer d'un modèle existant à une **conception innovante** exploitant les possibilités uniques de l'impression 3D. Elle démontre que l'impression 3D ne sert pas uniquement à reproduire des objets, mais à **créer des formes impossibles autrement** — au prix d'une compréhension fine des contraintes physiques du procédé. --- ## Séance 3 — Tour de Chute Libre « Spiral Hourglass » ### 1. Description du projet Ce projet consiste en la modélisation et la fabrication d'un objet cinétique de type **« fidget »** : un sablier à spirale. Une bille d'acier descend par gravité le long d'une trajectoire hélicoïdale creusée dans un volume en forme d'hyperboloïde, le tout enfermé dans une coque externe transparente ou évidée. **Objectifs :** - Étudier la géométrie complexe de l'objet (surfaces courbes et trajectoires hélicoïdales). - Réaliser une rétro-ingénierie d'un modèle existant pour le rendre paramétrique. - Fabriquer l'objet en impression 3D **sans supports**. **[ ![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/k5pimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/k5pimage.png)[![Screenshot 2026-02-04 183629.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/screenshot-2026-02-04-183629.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/screenshot-2026-02-04-183629.png)** ### 2. Analyse Technique et Modélisation Pour dépasser la simple impression de fichiers STL figés, j'ai opté pour une **re-conception paramétrique sous OpenSCAD**. Cela permet de modifier la taille de la bille, la vitesse de chute (nombre de tours) et les tolérances d'impression. #### 2.1 Concepts géométriques L'objet repose sur deux primitives mathématiques principales : - **L'Hyperboloïde à une nappe (le corps)** : la forme de « sablier » n'est pas deux cônes accolés, mais une structure continue qui permet une transition fluide pour la bille. - **L'Hélice (la trajectoire)** : la rainure suit une courbe hélicoïdale dont le rayon varie en fonction de la hauteur Z. #### 2.2 Le code paramétrique (OpenSCAD) ```c // Spiral Hourglass Fidget /* General Dimensions */ total_height = 80; max_diameter = 40; min_diameter = 20; wall_thickness = 1.6; clearance = 0.3; /* Ball & Path */ ball_diameter = 9.5; groove_depth_ratio = 0.6; twists = 2.0; resolution = 100; /* Rendering */ part_to_show = "both"; // [both, inner, outer] $fn = 60; R_max = max_diameter / 2; R_min = min_diameter / 2; path_radius_offset = (ball_diameter / 2) + 0.5; if (part_to_show == "inner" || part_to_show == "both") { translate([-max_diameter/1.5, 0, 0]) Inner_Core(); } if (part_to_show == "outer" || part_to_show == "both") { translate([max_diameter/1.5, 0, 0]) Outer_Shell(); } ``` ### 3. Fabrication
ParamètreValeur
ImprimantePrusa MK4S
MatériauPLA rouge
Buse0.4 mm
Hauteur de couche0.2 mm
Remplissage15 % Gyroid
Supports**AUCUN**
AdhérenceBrim de 5 mm
### 4. Itérations et difficultés rencontrées [ ![IMG_8021.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/img-8021.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/img-8021.jpeg) *Légende : Spiral Hourglass imprimé en PLA rouge. La spirale interne torsadée est visible à travers les ouvertures de la coque externe.* **Tentative initiale — manque de stabilisation** Lors de la première impression, la pièce a souffert d'un **manque d'adhérence au plateau** dû à sa base étroite. Les premières couches ont commencé à se décoller, ce qui a généré : - Un **léger déport** des couches supérieures (effet « tour de Pise »). - Des **stries irrégulières** sur la spirale, bloquant la bille à mi-parcours. **Ajustements pour la version finale :** - Ajout d'un **brim de 8 mm** pour stabiliser la base. - **Réduction de la vitesse** sur les premières couches à 30 mm/s. - Augmentation de la variable clearance (0.3 → 0.4) pour plus de jeu à la bille. ### 5. Conclusion Ce projet a permis de comprendre concrètement comment **la géométrie d'un objet conditionne sa fabricabilité** : un modèle qui s'imprime « sans supports » sur le papier peut quand même échouer si l'on néglige l'adhérence ou la stabilisation pendant l'impression. --- ## Séance 4 — Conception d'un objet fonctionnel : Support MagSafe ### 1. Objectif de la séance Après avoir exploré la **forme impossible** (Séance 2) et l'**objet cinétique** (Séance 3), cette séance visait à concevoir un **objet fonctionnel du quotidien** entièrement personnalisé : un **support de chargeur MagSafe**. ### 2. Cahier des charges - **Maintien stable** du chargeur MagSafe à hauteur de bureau. - **Inclinaison ergonomique** pour faciliter la lecture du téléphone pendant la charge. - **Passage caché du câble** à travers le pied du support. - **Base lourde** pour éviter le basculement. - **Print-in-place** : impression en une seule pièce sans assemblage. ### 3. Modélisation OpenSCAD ```c // Support MagSafe paramétrique base_diameter = 80; base_height = 8; stem_diameter = 14; stem_height = 60; puck_diameter = 56; puck_thickness = 6; ring_thickness = 3; cable_diameter = 4.5; $fn = 100; difference() { union() { cylinder(h = base_height, d = base_diameter); translate([0, 0, base_height]) cylinder(h = stem_height, d = stem_diameter); translate([0, 0, base_height + stem_height]) cylinder(h = puck_thickness + ring_thickness, d = puck_diameter + 2 * ring_thickness); } translate([0, 0, base_height + stem_height + ring_thickness]) cylinder(h = puck_thickness + 1, d = puck_diameter); translate([0, 0, -1]) cylinder(h = base_height + stem_height + 2, d = cable_diameter * 1.5); translate([0, 0, base_height / 2]) rotate([0, 90, 0]) cylinder(h = base_diameter / 2 + 1, d = cable_diameter * 1.5); } ``` ### 4. Paramètres d'impression
ParamètreValeur
ImprimantePrusa MK4S
MatériauPLA noir mat
Hauteur de couche0.2 mm
Remplissage30 % gyroid (poids accru pour stabilité)
SupportsActivés sur la couronne uniquement
Bordure4 mm
### 5. Résultat [ ![IMG_8038.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/img-8038.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/img-8038.jpeg)[![IMG_8040.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/img-8040.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/img-8040.jpeg) *Légende : (1) Support MagSafe vide. La couronne supérieure est creusée pour accueillir précisément le diamètre du chargeur Apple. (2) Support en utilisation avec le chargeur MagSafe inséré. Le câble sort proprement par la base.* ### 6. Itérations et apprentissages - **Première version** : diamètre interne de la couronne trop large (57 mm), le chargeur ne tenait pas → resserré à 56 mm. - **Deuxième version** : base trop fine (4 mm), le support basculait → épaissie à 8 mm avec remplissage à 30 %. - **Sortie de câble** : refait sortie radiale au niveau de la base. ### 7. Aspect innovant - **La paramétrisation** : un seul fichier OpenSCAD permet de regénérer un support pour n'importe quel chargeur en changeant trois variables. - **L'intégration native du câble** : impossible à réaliser proprement avec un produit moulé en une seule pièce sans usinage interne. - **L'ajustement par friction** : tolérance contrôlée à 0,2 mm près grâce au paramétrique. --- ## Séance 5 — Initiation à Arduino ### 1. Objectif global Cette séance d'initiation à **Arduino** vise à découvrir l'autre versant du prototypage : l'**électronique programmable**. À travers une série d'exercices progressifs, j'ai pris en main la carte Arduino Uno, l'IDE Arduino, et la logique des entrées/sorties numériques et analogiques. ### 2. Matériel utilisé - Carte Arduino Uno - Câble USB - Planche à pain (breadboard) - LEDs (×2) - Résistances (220 Ω et 10 kΩ) - Potentiomètre 10 kΩ - Bouton poussoir - Fils de connexion - Ordinateur avec Arduino IDE ### 3. Projet 1.1 — Blink : faire clignoter une LED Le programme **Blink** est l'exemple « hello world » d'Arduino : il fait clignoter la LED intégrée à la carte (broche 13) à intervalle régulier. ``` void setup() { pinMode(LED_BUILTIN, OUTPUT); } void loop() { digitalWrite(LED_BUILTIN, HIGH); delay(1000); digitalWrite(LED_BUILTIN, LOW); delay(1000); } ``` **Concepts découverts :** - Structure d'un programme Arduino : setup() (exécuté une fois) et loop() (boucle infinie). - Fonctions pinMode(), digitalWrite(), delay(). - Notion de **sortie numérique** (HIGH = 5V, LOW = 0V). **Anecdote :** lors du premier essai, la LED ne clignotait pas. Après vérification, le **port série n'avait pas été correctement sélectionné** dans l'IDE. Une fois corrigé, le clignotement a confirmé le bon fonctionnement. ### 4. Projet 1.2 — Read Analog Voltage : lecture d'un potentiomètre Mesurer la tension envoyée par un **potentiomètre** sur l'entrée analogique A0, et afficher la valeur dans le **moniteur série**. ```c void setup() { Serial.begin(9600); } void loop() { int sensorValue = analogRead(A0); float voltage = sensorValue * (5.0 / 1023.0); Serial.println(voltage); delay(100); } ```
Position du potentiomètreTension mesurée
Entrée 1 V (env.)≈ 1.02 V
Entrée 3 V (env.)≈ 2.98 V
Entrée 5 V (max)≈ 4.99 V
Le moniteur série affiche les valeurs en temps réel, ce qui permet de **visualiser concrètement la conversion d'un signal physique en donnée numérique** (résolution sur 10 bits = 1024 paliers entre 0 et 5V). ### 5. Projet 1.3 — Deux LEDs avec fréquences différentes Contrôler **deux LEDs simultanément** avec des temporisations différentes pour observer le caractère **séquentiel** de la fonction loop(). ```c void setup() { pinMode(13, OUTPUT); pinMode(12, OUTPUT); } void loop() { digitalWrite(13, HIGH); delay(500); digitalWrite(12, HIGH); delay(5); digitalWrite(13, LOW); delay(500); digitalWrite(12, LOW); delay(5); } ``` **Observations :** - LED 13 clignote lentement (≈ 1 Hz). - LED 12 clignote très rapidement. - Comme delay() est **bloquant**, les deux LEDs ne sont pas réellement indépendantes. → Cette limitation introduit la nécessité de techniques **non-bloquantes** (millis()) pour des projets plus complexes. ### 6. Projet 1.4 — Bouton poussoir interactif Utiliser un **bouton poussoir** comme entrée numérique pour contrôler l'état d'une LED. Le bouton est câblé en logique **active LOW** (avec résistance pull-up). ```c const int bouton = 4; const int led = 12; int etatBouton; void setup() { pinMode(bouton, INPUT); pinMode(led, OUTPUT); Serial.begin(9600); } void loop() { etatBouton = digitalRead(bouton); if (etatBouton == LOW) { digitalWrite(led, LOW); } else { digitalWrite(led, HIGH); } } ``` **Observations :** - Au repos : LED **allumée**. - Bouton appuyé : LED **éteinte**. Ce comportement contre-intuitif s'explique par le câblage **active LOW** : appuyer sur le bouton met la broche à la masse (0V = LOW). ### 7. Bilan de la séance Arduino Cette initiation à Arduino m'a permis de : - Maîtriser la structure de base d'un programme embarqué (setup / loop). - Manipuler des **sorties numériques** (LEDs) et des **entrées numériques** (bouton). - Lire un signal **analogique** et le convertir en données exploitables. - Comprendre les limites d'un programme séquentiel (delay() bloquant). - Diagnostiquer des problèmes physiques (câblage, port série) et logiques (logique inversée). L'Arduino constitue un outil de prototypage rapide complémentaire à l'impression 3D : là où l'impression 3D donne une **forme** à un objet, l'Arduino lui donne un **comportement**. Combiner les deux ouvre la voie à des projets d'**objets connectés** ou **interactifs**, qui constituent une suite naturelle à explorer. --- ## Conclusion générale Au cours de ces cinq séances, j'ai exploré progressivement les différentes facettes du prototypage rapide : 1. **Reproduction** d'un modèle existant (Creeper) → maîtrise de la chaîne STL → slicer → imprimante. 2. **Conception innovante** d'une forme impossible (cage sphérique) → exploitation de la spécificité de la fabrication additive, avec **trois itérations** pour maîtriser les contraintes physiques de l'impression FDM. 3. **Objet cinétique** complexe (Spiral Hourglass) → conception paramétrique d'une géométrie hélicoïdale. 4. **Objet fonctionnel** sur mesure (Support MagSafe) → personnalisation paramétrique d'un objet du quotidien. 5. **Électronique embarquée** (Arduino) → ajout du **comportement programmable** au prototypage. L'enseignement principal de ce parcours est que l'**innovation en prototypage** ne se limite jamais à la modélisation 3D ou au code : elle naît de l'**itération entre conception, fabrication, test et ajustement**. Chaque échec d'impression ou bug électronique a été l'occasion de mieux comprendre la matière, l'imprimante, ou l'algorithme — et c'est cette boucle d'apprentissage qui constitue le vrai cœur de la démarche FabLab. [ ![IMG_8272.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/scaled-1680-/img-8272.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-05/img-8272.jpeg) # Demir Yilmaz #### **Séance 1 (16/12/2025): Aston Martin DB5, Découverte de l’impression 3D** **Objectif du projet**
L’objectif de cette première séance était de découvrir les bases de l’impression 3D à travers un projet volontairement simple. Le choix d’un objet déjà modélisé permettait de se concentrer sur l’utilisation du slicer, la compréhension des réglages essentiels et le déroulement d’une impression, sans aborder la modélisation 3D. **Description du projet**
Le projet consiste à imprimer une voiture à partir d’un fichier STL existant. Ce type d’objet est bien adapté à une première approche, car il est rapide à imprimer, peu complexe et permet d’observer clairement la construction de l’objet couche par couche. **Matériel utilisé** - Imprimante 3D: Original Prusa MK4S - Filament: PLA **Logiciels utilisés** - Slicer : PrusaSlicer **Réglages d’impression** - Matériau: Generic PLA - Hauteur de couche: 0,20mm SPEED (modified) - Remplissage: 15% - Température de la buse: 200 °C - Température du plateau: 60 °C - Vitesse d’impression: paramètres par défaut de PrusaSlicer - Supports: non - Adhérence au plateau: par défaut **Étapes de réalisation**
1. Recherche et récupération d’un fichier STL du voiture Aston Martin DB5 - Vérifier l'échelle du modèle - Changement de l'orientation de l'objet et vérifier sa nouvelle position sur le plateau 2. Importation du fichier STL dans PrusaSlicer - Vérification des réglages standards - Changement de quelques réglages pour diminuer le temps d'impression 3. Génération du G-code - Lancement de l’impression 3D - Observation de la formation des couches et suivi du déroulement. 4. Surveiller la première couche 5. Récupération du modèle après impression **Observations et anecdotes**
Lors de l’impression, dû à la taille petite de la voiture, les lignes de la voiture ne sont pas assez fine et remarquable, ce qui affectue l'esthètique et finalement rend la voiture irréaliste. D'ailleurs, le fait de ne pas avoir ajouté du support sur les roues a affectué leurs états, avec les deux roues arrières qui ont effondrés.
**Résultat** L’impression s’est déroulée correctement. La voiture cependant à son tour, a des problèmes au niveau des roues, faute à l'enlèvement du support. D'ailleurs, un infill de 20% au lieu du 15% choisi, aurais pû être une bonne choix au niveau de l'esthètique.
[![image_2026-02-24_193359376.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/image-2026-02-24-193359376.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/image-2026-02-24-193359376.png)[![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/Wdximage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/Wdximage.png)
**Apprentissages** - Découverte des réglages de base dans PrusaSlicer - Compréhension de l’impact des paramètres d’impression - Importance de choisir un objet simple pour débuter en impression 3D #### **Séance 2 (09/01/2026): Conception d'objet difficile par OpenScad** **Objectif du projet**
Découvrir la modélisation paramétrique et la création d’objets 3D par code, permettant de modifier facilement la taille, l’épaisseur ou le motif d’un objet en ajustant quelques paramètres. **Description du projet** Un hand spinner, ou connu sous le nom de fidget spinner, avec son pièce du milieu qui quand serait prise à main, permettra la circulation de l'objet principale. [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/6Evimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/6Evimage.png) **Caractéristiques principales** Ce hand spinner est un objet de précision conçu pour une rotation fluide et équilibrée. - Équilibre parfait: Ses trois branches assurent une rotation stable et rapide. - Maintien central: Deux capsules s'emboîtent au milieu pour une prise en main facile. prolonger la durée de rotation. - Ajustement précis: Les dimensions sont optimisées pour accueillir un roulement standard. **Matériel utilisé** - Imprimante 3D: Original Prusa MK4S - Filament: PLA
**Logiciels utilisés** - Modélisation 3D: OpenSCAD - Slicer: PrusaSlicer **Outil de modélisation** Le modèle a été conçu avec le logiciel **OpenSCAD,** qui permet de créer des formes paramétriques à partir de code.
Les paramètres principaux définis sont: - Taille du roulement - Jeu d'assemblage - Épaisseur du spinner - Longueur des branches - Renfort du centre **Le code** ``` /* ASSEMBLAGE FINAL : HAND SPINNER RÉALISTE Ce projet comprend le corps du spinner et son système d'axe central. Les capsules argentées intègrent un axe qui traverse le roulement. */ // --- PARAMÈTRES PRINCIPAUX --- $fn = 80; // Résolution des courbes (plus élevé = plus lisse) bearing_diameter = 22; // Diamètre standard d'un roulement 608 bearing_thickness = 7; // Épaisseur standard du roulement tolerance = 0.15; // Jeu d'assemblage pour l'impression 3D body_h = 7; // Épaisseur du corps du spinner arm_length = 30; // Longueur des branches (centre vers extérieur) hub_diameter = 32; // Diamètre du renfort central // --- VALEURS CALCULÉES --- hole_d = bearing_diameter + (tolerance * 2); // Diamètre du trou ajusté // --- MODULE 1 : CORPS DU SPINNER --- module spinner_core() { difference() { // 1. FORME GLOBALE union() { // Moyeu central renforcé cylinder(d = hub_diameter, h = body_h, center = true); // Création des trois branches for (angle = [0 : 120 : 359]) { rotate([0, 0, angle]) { // Bras de liaison translate([arm_length/2, 0, 0]) cube([arm_length, 18, body_h], center = true); // Anneaux extérieurs (poids) translate([arm_length, 0, 0]) cylinder(d = hole_d + 8, h = body_h, center = true); } } } // 2. SOUSTRACTIONS (LES TROUS) // Logement du roulement central cylinder(d = hole_d, h = body_h + 5, center = true); // Logements des roulements extérieurs for (angle = [0 : 120 : 359]) { rotate([0, 0, angle]) translate([arm_length, 0, 0]) cylinder(d = hole_d, h = body_h + 5, center = true); } // 3. DÉCOUPES ESTHÉTIQUES (Allègement) for (angle = [60 : 120 : 359]) { rotate([0, 0, angle]) translate([hub_diameter * 0.65, 0, 0]) scale([1.2, 0.8, 1]) // Forme ovale cylinder(d = 10, h = body_h + 5, center = true); } } } // --- MODULE 2 : SYSTÈME DE MAINTIEN (CAPSULES) --- // Capsule supérieure avec axe long module cap_top() { union() { // Surface de contact pour le pouce difference() { cylinder(d = 20, h = 2); translate([0,0,3]) sphere(r=15); // Creux ergonomique } // Rebord d'appui sur le roulement translate([0,0,-1.5]) cylinder(d=12, h=1.5); // Axe central (traverse le roulement) translate([0, 0, -8]) cylinder(d = 7.7, h = 8); } } // Capsule inférieure avec logement module cap_bottom() { difference() { union() { // Surface de contact pour l'index difference() { cylinder(d = 20, h = 2); translate([0,0,3]) sphere(r=15); // Creux ergonomique } // Rebord d'appui sur le roulement translate([0,0,-1.5]) cylinder(d=12, h=1.5); } // Trou pour recevoir l'axe de la capsule supérieure translate([0, 0, -2]) cylinder(d = 7.9, h = 5); } } // --- ASSEMBLAGE FINAL --- // Affichage du corps (en Or) color("Gold") spinner_core(); // Affichage de la capsule supérieure (en Argent) translate([0, 0, 3.5]) color("Silver") cap_top(); // Affichage de la capsule inférieure (en Argent, inversée) translate([0, 0, -3.5]) rotate([180, 0, 0]) color("Silver") cap_bottom(); ``` **Résultat**
Le rendu nous propose une fidget spinner fonctionnel, quand tenu depuis le point central, puis le tournage de la pièce principale. Cette pièce est un démonstrateur de fabrication additive, car sa fonction dépend directement du point central qui est une diffèrente pièce. **Apprentissages techniques** - Découverte de la modélisation 3D par programmation avec OpenSCAD. - Compréhension du flux: code → STL → slicer → impression. - Importance du choix des paramètres pour obtenir un objet fonctionnel et agréable à utiliser. **Conclusion** Cette séance m’a permis de passer d'un modèle existant, à une conception innovante, exploitant les possibilités uniques de l’impression 3D. Elle démontre que l’impression 3D ne sert pas uniquement à reproduire des objets, mais à créer des formes impossibles autrement. #### **Séance 3 (16/01/2026): Modélisation d'un objet fonctionnel** **Objectif du projet**
L’objectif de cette séance est de :
-
- Imprimer un objet fonctionnel et mécanique - Comprendre l’importance des tolérances dans les mécanismes imprimés - Analyser les causes d’un échec d’impression fonctionnel - Mettre en place des solutions de post-traitement pour rendre l’objet utilisable.
**Description du projet** Ce projet consiste en la modélisation 3D d'un sablier fonctionnel conçu pour l'impression 3D, doté d'une structure renforcée par des colonnes de support latérales. Il intègre des réservoirs creux aux extrémités permettant de contenir du sable, ainsi que des couvercles amovibles pour un remplissage et une utilisation réelle. L'ensemble du code OpenSCAD a été optimisé pour garantir une étanchéité géométrique (manifold) et une solidité structurelle lors de la fabrication. [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/rLgimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/rLgimage.png)[![IMG_0007.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/scaled-1680-/img-0007.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/img-0007.jpeg) **Matériel utilisé** - Imprimante 3D: Original Prusa MK4S - Filament: PLA
**Logiciels utilisés** - Modélisation 3D: OpenSCAD - Slicer: PrusaSlicer **Caractéristiques du code** - Structure Monobloc: Un corps en sablier avec réservoirs intégrés et colonnes de soutien en tripode (120°) pour une stabilité maximale. - Conception Creuse: Utilisation de fonctions soustractives (`difference`) pour créer des parois de **2 mm**, garantissant la rétention du sable. - Optimisation Impression 3D: Gestion des chevauchements (`overlap`) pour éviter les erreurs de tranchage et assurer une fusion parfaite des pièces. - Système Ouvert: Réservoirs percés au centre pour permettre l'écoulement du sable et le remplissage via des bouchons amovibles. ``` // --- RÉGLAGES DE RÉSOLUTION --- $fn = 60; // Définit la finesse des arrondis (60 est un bon compromis vitesse/qualité) // --- PARAMÈTRES GLOBAUX --- h_totale = 70; // Hauteur totale du corps en verre r_base = 20; // Rayon de la base du verre epaisseur = 2; // Épaisseur des parois (important pour la solidité) passage = 5; // Diamètre du goulot d'étranglement (passage du sable) h_boite = 8; // Hauteur des réservoirs aux extrémités overlap = 0.05; // Petit décalage pour fusionner les pièces (évite les erreurs de manifold) // --- MODULE : GÉOMÉTRIE DU VERRE --- // Crée deux cônes inversés qui se rejoignent au centre module forme_sablier(r, h, p) { union() { // Cône supérieur : part du centre (p) vers le haut (r) translate([0, 0, h/2 - overlap]) cylinder(r1 = p, r2 = r, h = h/2 + overlap); // Cône inférieur : part de la base (r) vers le centre (p) cylinder(r1 = r, r2 = p, h = h/2 + overlap); } } // --- ASSEMBLAGE FINAL --- union() { // 1. LE CORPS EN VERRE CREUX difference() { // Forme extérieure pleine forme_sablier(r_base, h_totale, passage); // Forme intérieure soustraite (plus petite) pour créer le vide translate([0, 0, epaisseur]) forme_sablier(r_base - epaisseur, h_totale - (epaisseur * 2), passage - (epaisseur/2)); } // 2. LES RÉSERVOIRS (HAUT ET BAS) for (z = [0, h_totale]) { translate([0, 0, z]) difference() { // Cylindre extérieur de la boîte cylinder(r = r_base + 4, h = h_boite, center = true); // Évidement pour stocker le sable (laisse un fond de protection) translate([0, 0, (z == 0 ? epaisseur : -epaisseur)]) cylinder(r = r_base + 2, h = h_box, center = true); // Perçage central pour laisser couler le sable dans le verre cylinder(r = passage - 1, h = h_boite + 2, center = true); } } // 3. LES COLONNES DE SOUTIEN (TRIPODE) // Positionnées à 120° pour une stabilité maximale et un look esthétique for (a = [0, 120, 240]) { rotate([0, 0, a]) translate([r_base + 2, 0, 0]) cylinder(r = 2.5, h = h_totale); } } ``` **Paramètres d'Impression (Slicer)** Le modèle est conçu pour être imprimé sans supports.
- Imprimante : Prusa MK4 - Hauteur de couche: 0.15mm (Quality). Le 0.2mm est possible, mais le 0.15mm permet aux parois inclinées du sablier d'être plus lisses et plus étanches au sable - Remplissage (Infill): 15% Gyroid. Meilleur choix pour la structure interne des colonnes - Supports: OBLIGATOIRES (Partiels). Option "Supports sur le plateau uniquement" (Support on build plate only) - Adhérence : Brim de 5mm (indispensable car les 3 colonnes et la pointe du sablier ont peu de surface de contact) - Périmètre: 3 **Résultat**
Après post-traitement et activation manuelle :
- Le sablier est fonctionnel - L’objet remplit son usage de versemenent de sable vers les deux côtés.
────────────────────────────────────────────────────────
#### **Partie Arduino avec Kristina et Bence** [**-----> CLIQUEZ-ICI**](https://wiki.fablab.sorbonne-universite.fr/BookStack/books/projets-due-2025-2026/page/kristina-bence-demir-partie-arduino)
# Kashperuk Kristina ## **Rapports sur les projets** --- ### Projet 1 - Impression 3D ### Nom du projet **Création d’un objet de décoration 3D – Grumpy Cat** ### Coordonnées - **Nom :** Kashperuk - **Prénom :** Kristina - **Adresse mail :** Kristina.Kashperuk@etu.sorbonne-universite.fr - **Cursus / Labo :** Processus Innovation - au FABLAB ### Introduction - **Date de début du projet :** 16/12/2025 - **Date de fin :** 16/12/2025 ### Objectifs L’objectif de ce projet était de concevoir et imprimer en 3D un **objet décoratif pour une chambre**, représentant le personnage **Grumpy Cat**. Ce projet avait pour but de : - Comprendre le fonctionnement général de l’impression 3D - Savoir préparer un modèle 3D pour l’impression (slicing) - Maîtriser les paramètres essentiels d’impression - Produire un objet final esthétique et fonctionnel en tant que décoration ### Contexte Ce projet s’inscrit dans une démarche de **découverte et de pratique de la fabrication additive**, plus précisément l’impression 3D par dépôt de filament fondu (FDM). Il a été réalisé dans un cadre pédagogique afin de se familiariser avec les outils, logiciels et machines de fabrication numérique. ### Matériaux / Outils / Machines #### Matériaux - **Filament :** PLA "Machines 3D" - **Diamètre du filament :** 1,75 mm - **Couleur :** Dorée ("Gold") #### Machines - **Imprimante 3D :** Imprimante FDM - **Buse :** 0,4 mm #### Logiciels - **Logiciel de slicing :** PrusaSlicer - **Logiciel de visualisation / récupération du modèle 3D :** - Plateforme de modèles 3D Printables #### Outils complémentaires - Spatule pour décoller l’objet du plateau - Clé USB pour le transfert du fichier G-code ### Construction #### Fichiers - **Modèle 3D :** Grumpy Cat (fichier STL) - **Fichier d’impression :** G-code généré via PrusaSlicer #### Paramètres d’usinage / d’impression - **Température de la buse :** 200 °C - **Température du plateau :** 60 °C - **Matériau :** PLA - **Remplissage (infill) :** 20 % - **Épaisseur de couche :** 0,2 mm (qualité standard) - **Vitesse d’impression :** Paramètres par défaut PrusaSlicer - **Supports :** non - **Adhérence plateau :** Brim ou skirt (paramètres par défaut) #### Étapes de fabrication 1. Sélection du modèle 3D “Grumpy Cat” 2. Importation du fichier STL dans PrusaSlicer 3. Réglage des paramètres d’impression 4. Génération du fichier G-code 5. Lancement de l’impression sur l’imprimante 3D 6. Retrait de l’objet une fois l’impression terminée #### Visuels - Captures d’écran dans PrusaSlicer [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/kihimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/kihimage.png) - Photo de l’objet final [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/qYiimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/qYiimage.png) ### Journal de bord #### 16/12/2025 - Découverte de l’impression 3D - Choix d’un objet décoratif simple - Recherche d’un modèle 3D représentant Grumpy Cat - Importation du modèle dans PrusaSlicer - Ajustement des paramètres d’impression - Vérification de l’orientation et de la stabilité du modèle - Lancement de l’impression 3D - Surveillance du bon déroulement de l’impression - Retrait de l’objet du plateau - Résultat final : objet de décoration Grumpy Cat imprimé avec succès ### Conclusion Ce projet m’a permis de comprendre les bases de l’impression 3D, depuis la préparation du modèle jusqu’à l’obtention d’un objet final. L’impression de Grumpy Cat en tant qu’objet décoratif a été une expérience enrichissante, démontrant les possibilités créatives offertes par la fabrication numérique. --- ### Projet 2 - Impression 3D ### Nom du projet **Création d’un objet innovant 3D – Maquette de jouet interactif pour chat : Circuit à bille captive** ### Coordonnées - **Nom :** Kashperuk - **Prénom :** Kristina - **Adresse mail :** Kristina.Kashperuk@etu.sorbonne-universite.fr - **Cursus / Labo :** Processus Innovation - au FABLAB ### Introduction - **Date de début du projet :** 16/01/2026 - **Date de fin :** 16/01/2026 ### Objectifs L’objectif de ce projet était de concevoir et d'imprimer une maquette fonctionnelle de jouet pour chat : un circuit circulaire (tube) contenant une bille mobile et impossible à extraire. Ce projet visait à : - Maîtriser la **conception paramétrique** sous OpenSCAD. - Gérer une **pause programmée** durant l'impression pour insérer un élément externe. - Comprendre les tolérances de mouvement (clearance) pour qu'un objet reste mobile après l'impression. ### Contexte Ce projet utilise la technique du "Print-in-place" avec insertion manuelle. Le défi technique résidait dans la synchronisation : la bille devait être prête avant que le tube ne commence à se refermer. ### Matériaux / Outils / Machines #### Matériaux - **Filament :** PLA "Machines 3D" - **Diamètre du filament :** 1,75 mm - **Couleur :** Violet ("Purple") #### Machines - **Imprimante 3D :** Imprimante FDM - **Buse :** 0,4 mm #### Logiciels - **Logiciel de slicing :** PrusaSlicer - **Logiciel de visualisation / récupération du modèle 3D :** - Plateforme de modèles 3D Printables #### Outils complémentaires - Spatule pour décoller l’objet du plateau - Clé USB pour le transfert du fichier G-code ### Construction #### Fichiers - **Fichiers Sources (.scad) :** \* `Ball_Kashperuk.scad` : Code de conception de la bille. - `Rack_Kashperuk.scad` : Code de conception du rail avec les paramètres de tunnel et de fente. - **Modèles 3D générés :** \* Fichiers STL exportés depuis OpenSCAD pour chaque élément. - **Fichiers d’impression (.bgcode) :** - `Ball_Kashperuk.bgcode` : Fichier binaire généré via PrusaSlicer pour l'impression de la bille. - `Rack_Kashperuk.bgcode` : Fichier contenant la commande de pause (M600) à 32 minutes pour l'insertion de la bille. #### Paramètres d’usinage / d’impression - **Température :** Buse 200 °C / Plateau 60 °C - **Remplissage :** 20 % - **Matériau :** PLA - **Épaisseur de couche :** 0,2 mm - **Temps total :** 1h03 (32 min avant pause + 31 min après pause) - **Supports :** non - **Adhérence plateau :** Brim ou skirt (paramètres par défaut) #### Étapes de fabrication 1. Conception du modèle paramétrique sur OpenSCAD. 2. Exportation de la bille seule et impression complète. 3. Exportation du rail et préparation du G-code sur PrusaSlicer avec une commande **M600 (Pause)** à la couche correspondant à la moitié du tunnel. 4. Lancement de l'impression du rail. 5. À 32 minutes, lors de la pause, insertion de la bille dans le rail. 6. Reprise de l'impression pour fermer la structure. #### Évolution de la programmation Initialement, j'avais écrit un programme unique pour imprimer la bille et le rail simultanément. Cependant, j'ai réalisé que lors de la pause automatique (nécessaire à la moitié de la hauteur du rail pour insérer la bille), la bille ne serait pas encore terminée ou serait difficile à détacher proprement pour l'insérer dans le tube. J'ai donc décidé de **scinder le projet en deux programmes distincts** : 1. **Le programme de la bille :** Imprimé en premier pour avoir l'objet prêt et refroidi. 2. **Le programme du rail :** Configuré avec une pause à **32 minutes** (moment où le tube commence à se refermer). Après l'insertion manuelle de la bille, les **31 minutes** restantes ont été imprimées pour sceller le jouet. #### Code OpenSCAD 1\. Code de la "Ball" : ``` // Paramètres de base ball_diameter = 12; $fn = 75; // Génération de la bille seule sphere(d = ball_diameter); ``` 1\. Code de la "Rack" : ```c // Paramètres track_outer_radius = 60; track_width = 20; track_height = 15; ball_diameter = 12; clearance = 2.0; // Espace pour le roulement $fn = 100; tunnel_center_r = track_outer_radius - (track_width / 2); tunnel_size = ball_diameter + clearance; difference() { // Corps principal (Le tore) rotate_extrude() translate([tunnel_center_r - (track_width/2), 0]) square([track_width, track_height]); // Tunnel interne (Le vide pour la bille) translate([0, 0, track_height / 2]) rotate_extrude() translate([tunnel_center_r, 0]) circle(d = tunnel_size); // Fente supérieure (Ouverture pour le chat, plus étroite que la bille) translate([0, 0, track_height - 1]) rotate_extrude() translate([tunnel_center_r, 0]) square([ball_diameter * 0.7, 5], center = true); } ``` #### Visuels - Captures d’écran dans PrusaSlicer [![Capture d’écran 2026-01-30 144343.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/capture-decran-2026-01-30-144343.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/capture-decran-2026-01-30-144343.png)[ ![Capture d’écran 2026-01-30 144507.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/capture-decran-2026-01-30-144507.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/capture-decran-2026-01-30-144507.png) - Pause d'impression[![Capture d’écran 2026-01-30 145805.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/capture-decran-2026-01-30-145805.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/capture-decran-2026-01-30-145805.png) - Video-presentation de l’objet final ### Journal de bord #### 16/01/2026 - Développement du code OpenSCAD et calcul des rayons de courbure. - Analyse du workflow. Décision de séparer les fichiers pour garantir que la bille soit disponible au moment de la pause. - Impression de la bille (12mm). - Slicing du rail et identification de la couche de pause (début de la courbure intérieure). - Lancement du rail. - Pause de l'imprimante. Insertion de la bille. - Fin de l'impression. La bille est parfaitement captive et roule librement. ### Conclusion Ce projet a été un succès. La séparation du code en deux étapes était la solution optimale pour gérer les contraintes de temps de l'imprimante. Le résultat est un objet interactif fonctionnel qui démontre l'utilité des pauses programmées pour créer des mécanismes complexes "imprimés dans la masse". # Jacques YE #### **Séance 1 (16/12/2025) : Porte-clé Pikachu – Découverte de l’impression 3D** > ***Les mots surlignés dans ce document le sont en jaune clair, afin de mettre en évidence uniquement les éléments critiques (sécurité, paramètres importants), sans surcharger la lecture.***

**Ce projet s’inscrit dans une séance d’initiation à l’impression 3D au Fab Lab de Sorbonne Université. Il a pour objectif de découvrir le fonctionnement général d’une imprimante 3D ainsi que la prise en main du logiciel de slicing PrusaSlicer.**

- ##### **Objectif du projet** L’objectif de cette première séance était de découvrir les bases de l’impression 3D à travers un projet volontairement simple. Le choix d’un objet déjà modélisé permettait de se concentrer sur l’utilisation du slicer, la compréhension des réglages essentiels et le déroulement d’une impression, sans aborder la modélisation 3D. - ##### **Description du projet** Le projet consiste à imprimer un porte-clé Pikachu à partir d’un fichier STL existant. Ce type d’objet est bien adapté à une première approche, car il est rapide à imprimer, peu complexe et permet d’observer clairement la construction de l’objet couche par couche. - ##### **Matériel utilisé** - **Imprimante 3D :** Original Prusa MK4S - **Filament** : PLA - ##### **Logiciels utilisés** - **Slicer** : PrusaSlicer - ##### **Réglages d’impression** Les réglages utilisés sont des réglages standards, adaptés à un objet simple et à une première impression. - - **Matériau : PLA** - **Hauteur de couche : 0,15 mm (SPEED)** - **Remplissage : 20 %** - **Température de la buse : 200 °C** - **Température du plateau : 60 °C** - **Vitesse d’impression : paramètres par défaut de PrusaSlicer** - **Supports : non** - **Adhérence au plateau : par défaut**

**Il est indispensable de surveiller la première couche de l’impression. Il ne faut jamais toucher la buse ou le plateau lorsqu’ils sont chauds afin d’éviter tout risque de brûlure.**

- ##### **Étapes de réalisation** 1. 1. Recherche et récupération d’un fichier STL de porte-clés Pikachu - Vérifier l'échelle du modèle - Vérifier l'orientation et la position sur le plateau 2. Importation du fichier STL dans PrusaSlicer - Vérification des réglages standards - Ajustement si nécessaire 3. Génération du G-code 4. Lancement de l’impression 3D 5. Observation de la formation des couches et suivi du déroulement. - Surveiller la première couche - Ajouter un brim si nécessaire pour l'adhérence - ##### **Observations et anecdotes**
Lors de l’impression, la première couche a légèrement gondolé sur un coin du plateau. L’ajout d’un petit brim a permis d’améliorer l’adhérence et de corriger ce problème.
>
*« C’était impressionnant de voir le filament se déposer couche par couche et de constater comment la forme de l’objet apparaissait progressivement. »*

**Pour les petits objets, l’utilisation d’un brim est souvent efficace pour améliorer l’adhérence au plateau.**

- ##### **Résultat** L’impression s’est déroulée correctement après ajustement de l’adhérence. Le porte-clé obtenu est fonctionnel et le rendu est conforme au modèle initial. [![Capture d’écran 2026-01-09 113936.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/capture-decran-2026-01-09-113936.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/capture-decran-2026-01-09-113936.png)[![IMG_20260109_171117.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/img-20260109-171117.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/img-20260109-171117.jpg) - ##### **Limites du projet**
Ce projet présente plusieurs limites liées à son cadre d’initiation :
- Le fichier STL n’a pas été modifié, la phase de modélisation n’a donc pas été abordée. - Les réglages avancés de PrusaSlicer n’ont pas été explorés. - Le projet ne permet pas d’évaluer la résistance mécanique de la pièce. - L’impression a été réalisée uniquement en PLA, sans comparaison avec d’autres matériaux.
- ##### **Apprentissages** - Découverte des réglages de base dans PrusaSlicer - Compréhension de l’impact des paramètres d’impression - Importance de choisir un objet simple pour débuter en impression 3D

**Cette première séance a permis d’acquérir les bases nécessaires pour aborder des projets d’impression 3D plus complexes lors des prochaines séances.**

\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ #### **Séance 2 (09/01/2026) : Bracelet paramétrique – Modélisation avec OpenSCAD**

**Ce projet a pour objectif de découvrir la modélisation 3D par programmation avec OpenSCAD. L’objet est entièrement créé par code avant d’être exporté en STL pour l’impression 3D.**

- ##### **Objectif du projet** Découvrir la modélisation paramétrique et la création d’objets 3D par code, permettant de modifier facilement la taille, l’épaisseur ou le motif d’un objet en ajustant quelques paramètres. - ##### **Description du projet** Le bracelet comporte un motif répétitif en “V” sur toute sa longueur. L’utilisation d’OpenSCAD permet d’ajuster rapidement la taille, l’épaisseur et le nombre de motifs en modifiant quelques paramètres dans le code. - ##### **Matériel utilisé** - **Imprimante 3D :** Original Prusa MK4S - **Filament** : PLA - ##### **Logiciels utilisés** - **Modélisation 3D** : OpenSCAD - **Slicer** : PrusaSlicer - ##### **Principe de modélisation** - Création d’un motif élémentaire en forme de “V”. - Répétition automatique du motif à l’aide de boucles `for`. - Paramètres ajustables pour dimensions et nombre de motifs. Cette approche permet de modifier rapidement le design sans redessiner l’objet. Code : ```c // BRACELET PARAMETRIQUE // ================== FONCTIONS ================== function deg2rad(a) = a * PI / 180; // conversion degrés → radians // ================== PARAMÈTRES ================== radius = 35; // rayon du bracelet no_segs = 19; // nombre de segments width = 9; // largeur du bracelet $fn = 140; // qualité de rotation step = 360 / no_segs; // angle entre segments // ================== POINTS DES SEGMENTS ================== p1=[7.5,width/2,-radius+5.1]; p2=[2.5,0,-radius+5.1]; p3=[6.5,width/2,-radius+5.1]; p4=[1.5,0,-radius+5.1]; p5=[6.5,width/2,-radius+0.9]; p6=[1.5,0,-radius+0.9]; p7=[7.5,width/2,-radius+0.9]; p8=[2.5,0,-radius+0.9]; p9=[-2.5,width/2,-radius+5.1]; p10=[-7.5,0,-radius+5.1]; p11=[-1.5,width/2,-radius+5.1]; p12=[-6.5,0,-radius+5.1]; // ================== ROTATIONS ================== ang1 = -step/2; ang2 = 2*ang1; n = 1; // rotation des points p1_t = [p1[0]*cos(deg2rad(ang1))-p1[2]*sin(deg2rad(ang1)), p1[1], p1[0]*sin(deg2rad(ang1))+p1[2]*cos(deg2rad(ang1))]; p2_t = [p2[0]*cos(deg2rad(ang1))-p2[2]*sin(deg2rad(ang1)), p2[1], p2[0]*sin(deg2rad(ang1))+p2[2]*cos(deg2rad(ang1))]; p3_t = [p3[0]*cos(deg2rad(ang1))-p3[2]*sin(deg2rad(ang1)), p3[1], p3[0]*sin(deg2rad(ang1))+p3[2]*cos(deg2rad(ang1))]; p4_t = [p4[0]*cos(deg2rad(ang1))-p4[2]*sin(deg2rad(ang1)), p4[1], p4[0]*sin(deg2rad(ang1))+p4[2]*cos(deg2rad(ang1))]; p1_t_ = [p1_t[0], -p1_t[1], p1_t[2]]; p2_t_ = [p2_t[0], -p2_t[1], p2_t[2]]; p3_t_ = [p3_t[0], -p3_t[1], p3_t[2]]; p4_t_ = [p4_t[0], -p4_t[1], p4_t[2]]; p5_t = [p5[0]*cos(deg2rad(ang2))-p5[2]*sin(deg2rad(ang2)), p5[1], p5[0]*sin(deg2rad(ang2))+p5[2]*cos(deg2rad(ang2))]; p6_t = [p6[0]*cos(deg2rad(ang2))-p6[2]*sin(deg2rad(ang2)), p6[1], p6[0]*sin(deg2rad(ang2))+p6[2]*cos(deg2rad(ang2))]; p7_t = [p7[0]*cos(deg2rad(ang2))-p7[2]*sin(deg2rad(ang2)), p7[1], p7[0]*sin(deg2rad(ang2))+p7[2]*cos(deg2rad(ang2))]; p8_t = [p8[0]*cos(deg2rad(ang2))-p8[2]*sin(deg2rad(ang2)), p8[1], p8[0]*sin(deg2rad(ang2))+p8[2]*cos(deg2rad(ang2))]; p5_t_ = [p5_t[0], -p5_t[1], p5_t[2]]; p6_t_ = [p6_t[0], -p6_t[1], p6_t[2]]; p7_t_ = [p7_t[0], -p7_t[1], p7_t[2]]; p8_t_ = [p8_t[0], -p8_t[1], p8_t[2]]; p9_t = [p9[0]*cos(deg2rad(n*ang1))-p9[2]*sin(deg2rad(n*ang1)), p9[1], p9[0]*sin(deg2rad(n*ang1))+p9[2]*cos(deg2rad(n*ang1))]; p10_t = [p10[0]*cos(deg2rad(n*ang1))-p10[2]*sin(deg2rad(n*ang1)), p10[1], p10[0]*sin(deg2rad(n*ang1))+p10[2]*cos(deg2rad(n*ang1))]; p11_t = [p11[0]*cos(deg2rad(n*ang1))-p11[2]*sin(deg2rad(n*ang1)), p11[1], p11[0]*sin(deg2rad(n*ang1))+p11[2]*cos(deg2rad(n*ang1))]; p12_t = [p12[0]*cos(deg2rad(n*ang1))-p12[2]*sin(deg2rad(n*ang1)), p12[1], p12[0]*sin(deg2rad(n*ang1))+p12[2]*cos(deg2rad(n*ang1))]; p9_t_ = [p9_t[0], -p9_t[1], p9_t[2]]; p10_t_ = [p10_t[0], -p10_t[1], p10_t[2]]; p11_t_ = [p11_t[0], -p11_t[1], p11_t[2]]; p12_t_ = [p12_t[0], -p12_t[1], p12_t[2]]; // ================== BRACELET ================== union(){ for(i=[0:step:360-step]){ rotate([0,i,0]){ union(){ // Base polygon translate([0,0,-radius]) linear_extrude(1) polygon(points=[[-7.5,0], [-2.5,width/2], [7.5,width/2], [2.5,0], [7.5,-width/2], [-2.5,-width/2]]); // Chevauchement rotate([0,step/2,0]) translate([0,0,-radius+5]) linear_extrude(1) polygon(points=[[-7.5,0], [-2.5,width/2], [7.5,width/2], [2.5,0], [7.5,-width/2], [-2.5,-width/2]]); // Polyhedron segments hauts polyhedron(points=[[-1.5,width/2,-radius+0.9], p1_t, p2_t, [-6.5,0,-radius+0.9], [-2.5,width/2,-radius+0.9], p3_t, p4_t, [-7.5,0,-radius+0.9]], faces=[[1,0,2],[2,0,3],[4,5,7],[7,5,6],[5,4,1],[1,4,0], [2,3,6],[6,3,7],[3,0,7],[7,0,4],[6,5,2],[2,5,1]]); // Polyhedron segments bas polyhedron(points=[[-1.5,-width/2,-radius+0.9], p1_t_, p2_t_, [-6.5,0,-radius+0.9], [-2.5,-width/2,-radius+0.9], p3_t_, p4_t_, [-7.5,0,-radius+0.9]], faces=[[0,1,2],[0,2,3],[5,4,7],[5,7,6],[4,5,1],[4,1,0], [3,2,6],[3,6,7],[0,3,7],[0,7,4],[5,6,2],[5,2,1]]); // Polyhedron chevauchement segments suivants polyhedron(points=[p9_t, p5_t, p6_t, p10_t, p11_t, p7_t, p8_t, p12_t], faces=[[1,0,2],[2,0,3],[4,5,7],[7,5,6],[5,4,1],[1,4,0], [2,3,6],[6,3,7],[3,0,7],[7,0,4],[6,5,2],[2,5,1]]); polyhedron(points=[p9_t_, p5_t_, p6_t_, p10_t_, p11_t_, p7_t_, p8_t_, p12_t_], faces=[[0,1,2],[0,2,3],[5,4,7],[5,7,6],[4,5,1],[4,1,0], [3,2,6],[3,6,7],[0,3,7],[0,7,4],[5,6,2],[5,2,1]]); } } } } ``` - ##### **Étapes de réalisation** 1. 1. Écriture du code OpenSCAD pour définir la forme de base du bracelet - Création du motif en V - Répétition du motif par programmation 2. Ajustement des paramètres (taille, épaisseur, nombre de motifs) 3. Génération et visualisation du modèle 3D dans OpenSCAD 4. Export du modèle final au format STL 5. Import du STL dans PrusaSlicer pour préparation à l’impression - ##### **Réglages d’impression** - - **Matériau** : PLA - **Hauteur de couche** : 0,15 mm STRUCTURAL - **Remplissage** : 15 % - **Température de la buse** : 205 °C - **Température du plateau** : 60 °C - **Vitesse d’impression** : paramètres par défaut de PrusaSlicer - **Supports** : non - **Adhérence au plateau** : par défaut

**Lors des tests, il a été constaté que plus le rayon du bracelet est grand, plus la structure devient cassable. L’augmentation du rayon réduit la rigidité globale du bracelet et fragilise les zones entre les motifs.**

- ##### **Observations et anecdotes** - - La répétition du motif est régulière et le bracelet garde une légère souplesse, parfait pour être porté. - Voir un objet que j’ai entièrement conçu sortir de l’imprimante a été très motivant. > *« Créer un objet paramétrique et le voir imprimé exactement comme prévu est très satisfaisant. »*

**Les objets paramétriques permettent de tester facilement plusieurs variantes et d’ajuster les dimensions sans refaire toute la modélisation.**

- ##### **Résultat** Le projet aboutit à un bracelet imprimable, entièrement conçu par code. Le bracelet est confortable, léger et esthétiquement réussi. Grâce au caractère paramétrique, il sera facile de modifier le design ou d’en créer d’autres variantes rapidement. [![Capture d'écran 2026-01-14 183938.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/capture-decran-2026-01-14-183938.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/capture-decran-2026-01-14-183938.png)![Capture d'écran 2026-01-14 183835.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/capture-decran-2026-01-14-183835.png)[![vue 3 bracelet.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/vue-3-bracelet.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/vue-3-bracelet.png)[![1000847475.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/1000847475.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/1000847475.jpg) - ##### **Limites du projet**
- Objet simple avec un motif répétitif ; designs plus complexes nécessitent des connaissances supplémentaires en OpenSCAD. - Réglages avancés d’impression non explorés. - Impression réalisée uniquement en PLA.
- ##### **Apprentissages** - Découverte de la modélisation 3D par programmation avec OpenSCAD. - Compréhension du flux : code → STL → slicer → impression. - Importance du choix des paramètres pour obtenir un objet fonctionnel et agréable à utiliser. - Intérêt des objets paramétriques pour gagner du temps et tester différentes variantes.

**Cette séance a permis d’acquérir de nouvelles compétences en modélisation paramétrique et de consolider le flux complet de création d’un objet 3D par code jusqu’à son impression.**

\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ #### **Séance 3 (16/01/2026) – Boîte à dés mécanique : Impression 3D d’un mécanisme fonctionnel**

**Cette séance a pour objectif d’aller plus loin dans l’impression 3D en réalisant un objet mécanique complexe, composé de plusieurs pièces mobiles imprimées directement en une seule fois.**

- ##### **Objectif du projet**
L’objectif de cette séance est de :
- - imprimer un objet fonctionnel et mécanique, et non uniquement décoratif - comprendre l’importance des tolérances dans les mécanismes imprimés - analyser les causes d’un échec d’impression fonctionnel - mettre en place des solutions de post-traitement pour rendre l’objet utilisable.
- ##### **Description du projet**
Le projet consiste à imprimer une boîte à dés mécanique destinée aux jeux de société.
La boîte comporte :
- - sept compartiments pour des dés sphériques (diamètre maximal ≈ 2,7 cm) - un système d’ouverture rotatif actionné par une molette extérieure, - sept portes rainurées qui coulissent sur des rails circulaires internes.
En tournant la molette dans le sens antihoraire, les portes se déplacent et se rangent sous la boîte, libérant l’accès aux compartiments. La fermeture s’effectue en tournant la molette dans le sens inverse.
Toutes les pièces du mécanisme sont pré-assemblées dans un seul fichier STL.
- ##### **Matériel utilisé** - **Imprimante 3D :** Original Prusa MK4S - **Filament** : PLA - ##### **Logiciels utilisés** - **Modélisation 3D** : OpenSCAD - **Slicer** : PrusaSlicer
- ##### **Contraintes spécifiques du modèle**

**Le fonctionnement du mécanisme repose sur des vides volontairement intégrés entre les pièces mobiles. Ces espaces sont essentiels pour permettre la rotation et le coulissement des éléments après impression.**

**Toute modification des paramètres peut empêcher le mécanisme de fonctionner.**

- ##### **Choix et ajustements avant impression**
Afin de limiter le temps d’impression, la taille de la boîte a été réduite par rapport au modèle original.
Ce choix a été fait pour des raisons pratiques, mais il a eu un impact direct sur :
- - les tolérances mécaniques - le risque de fusion partielle des pièces mobiles
- ##### **Réglages d’impression** - **Matériau : PLA** - **Hauteur de couche : 0,10 FAST** - **première couche : 0,20 mm** - **couches suivantes : 0,16 mm** - **Buse : 0,4 mm** - **Remplissage : 10 %** - **Supports : non (déjà intégré dans le fichier STL)** - **Adhérence au plateau : activée** - **Orientation : face plate positionnée sur le plateau**
- ##### **Étapes de réalisation**
1. 1. Import du fichier STL dans PrusaSlicer 2. Ajustement de l’échelle pour réduire le temps d’impression 3. Vérification des paramètres recommandés 4. Génération du G-code 5. Lancement de l’impression 6. Test du mécanisme après refroidissement complet
- ##### **Observations et problèmes rencontrés**
Lors de la première impression, le mécanisme de rotation ne fonctionnait pas :
- - les éléments qui devaient tourner étaient complètement bloqués.
Les causes probables sont :
- - une fusion partielle des pièces mobiles, - une impression incorrecte des zones de vide volontaire
Une seconde tentative a permis d’obtenir un mécanisme fonctionnel, mais nécessitant un post-traitement manuel.
Les actions réalisées ont été :
- - retrait du support et de résidus à l’aide d’un scalpel - ponçage des zones de contact afin de réduire les frottements entre les pièces mobiles - nettoyage de l'objet à eau savonneuse - application d’une petite quantité d’huile d’olive pour faciliter le mouvement.
Au départ, le mécanisme restait difficile à activer. Il a été nécessaire d’appuyer sur certaines zones de la boîte, correspondant aux espaces vides prévus dans le design, afin d’amorcer la rotation.
>
*« Une fois le mécanisme débloqué manuellement, la rotation est devenue progressivement plus fluide. »*
- ##### **Résultat**
Après post-traitement et activation manuelle :
- - la boîte est fonctionnelle - le mécanisme d’ouverture et de fermeture fonctionne correctement, - l’objet remplit son usage initial de rangement de dés.
[![Capture d'écran 2026-01-25 113041.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/capture-decran-2026-01-25-113041.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/capture-decran-2026-01-25-113041.png)[![1000850549.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/1000850549.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/1000850549.jpg)
- ##### **Limites du projet** - Modèle très sensible aux réglages d’impression - Post-traitement nécessaire pour obtenir un fonctionnement correct - Le PLA limite la durabilité mécanique à long terme
- ##### **Apprentissages**
- - Compréhension concrète du rôle des tolérances mécaniques - Différence entre un échec esthétique et un échec fonctionnel - Importance du post-traitement pour les objets mécaniques imprimés - Impact direct de l’échelle sur le fonctionnement d’un mécanisme

**Malgré un échec initial, cette séance a permis de comprendre en profondeur les contraintes liées à l’impression de mécanismes complexes et d’aboutir à un objet fonctionnel.**

\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ #### Voir aussi : **[PROJET PROTOTYPAGE ARDUINO - Jacques YE, Claire UNG](https://wiki.fablab.sorbonne-universite.fr/BookStack/books/projets-due-2025-2026/page/projet-prototypage-arduino-jacques-ye-claire-ung "PROJET PROTOTYPAGE ARDUINO - Jacques YE, Claire UNG")** # Toufic Bitar # Séance 1 – Prise en main du slicer et impression d’un modèle existant ## 1. Objectif de la séance L’objectif de cette première séance était de comprendre concrètement le fonctionnement du processus d’impression 3D, depuis l’importation d’un modèle jusqu’à l’obtention de la pièce physique. Il s’agissait principalement de se familiariser avec le logiciel de tranchage (slicer), d’analyser les paramètres d’impression et de valider la chaîne complète de fabrication additive sur un premier objet simple. ## 2. Choix du modèle Pour cette première expérience, j’ai choisi de télécharger un fichier STL existant correspondant à une coque de téléphone. Ce choix était volontaire : il permettait de me concentrer exclusivement sur la préparation et l’impression du modèle sans introduire d’erreurs liées à la modélisation. L’objectif était d’évaluer la qualité dimensionnelle de l’imprimante et de vérifier la précision d’ajustement d’une pièce fonctionnelle. ### Contexte : j’ai choisi d’imprimer une coque de téléphone issue d’un modèle disponible en ligne. Ce modèle, aux formes organiques, m’a permis d’observer les capacités de l’impression 3D sur des surfaces courbes et des zones complexes, tout en mettant en évidence la nécessité d’utiliser des structures de support pour certaines parties lors de l’impression. Le lien du modèle: [https://www.printables.com/model/1086626-cover-clean-with-logo-iphone15-iphone15pro-iphone](https://www.printables.com/model/1086626-cover-clean-with-logo-iphone15-iphone15pro-iphone) ## 3. Préparation dans le slicer Le fichier STL a été importé dans le logiciel de tranchage. Une fois le modèle chargé, j’ai vérifié sa position sur le plateau d’impression ainsi que son orientation. L’option permettant de poser automatiquement le modèle sur le plateau a été utilisée afin d’assurer un contact optimal avec la surface d’impression. J’ai ensuite analysé les différents paramètres proposés par le profil sélectionné. Le profil “Fine – 0.15 mm” a été retenu afin d’obtenir une meilleure qualité de surface grâce à une hauteur de couche plus fine. Le remplissage a été configuré à 5 % avec un motif Cubic, ce qui permettait de réduire la consommation de matériau et le temps d’impression tout en conservant une rigidité suffisante pour ce type de pièce. Les supports n’ont pas été activés, car la géométrie du modèle ne présentait pas de surplombs critiques nécessitant un soutien supplémentaire. Après vérification des paramètres, le G-code a été généré pour lancer l’impression. [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/scaled-1680-/2JBimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/2JBimage.png) ## 4. Impression et résultat L’impression s’est déroulée sans incident. La pièce a correctement adhéré au plateau et aucune déformation ni défaut majeur n’a été observé pendant le processus. Les dimensions finales étaient conformes au modèle numérique et la coque s’est ajustée parfaitement au téléphone. Ce premier test a permis de valider la précision dimensionnelle de l’imprimante ainsi que la pertinence des paramètres choisis. Il m’a également permis de comprendre l’impact direct de la hauteur de couche, du taux de remplissage et de l’orientation du modèle sur le résultat final. [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/scaled-1680-/Ebiimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/Ebiimage.png)[![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/scaled-1680-/NBmimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/NBmimage.png) ## 5. Conclusion Cette séance constitue une étape fondamentale dans la prise en main de la fabrication additive. Elle m’a permis de comprendre le rôle central du slicer dans la transformation d’un modèle numérique en trajectoires d’extrusion et de me familiariser avec les paramètres essentiels influençant la qualité d’impression. Elle représente la base technique nécessaire avant de passer à des conceptions personnelles plus complexes. --- # Séance 2 – Conception paramétrique d’un mécanisme Print-in-Place ## 1. Objectif de la séance Après avoir validé la chaîne d’impression avec un modèle existant lors de la séance précédente, l’objectif de cette seconde séance était de concevoir un objet original à l’aide d’un logiciel de modélisation paramétrique. L’enjeu était de réaliser un mécanisme fonctionnel imprimé en une seule pièce, sans assemblage, afin d’explorer les possibilités spécifiques de la fabrication additive. Le projet retenu consistait à créer une capsule fermée contenant une bille captive à l’intérieur. La bille devait être libre de mouvement après impression, tout en restant enfermée dans la coque. ## 2. Principe du mécanisme L’objet repose sur le principe du **print-in-place**, qui consiste à imprimer simultanément plusieurs éléments mobiles sans étape d’assemblage. La capsule externe est creuse et contient une bille centrée dans la cavité interne. Un espace de tolérance (clearance) est volontairement introduit entre la bille et la paroi interne afin d’éviter la fusion des surfaces lors de l’impression. Ce type de géométrie met en évidence l’un des avantages majeurs de la fabrication additive : la possibilité de créer des mécanismes fermés impossibles à fabriquer par des procédés soustractifs classiques. ## 3. Modélisation paramétrique sous OpenSCAD La modélisation a été réalisée sous OpenSCAD, logiciel basé sur l’écriture de code. Cette approche paramétrique permet de modifier rapidement les dimensions de l’objet en ajustant uniquement les variables principales. Les paramètres principaux utilisés étaient les suivants : - Longueur de la capsule : 70 mm - Diamètre extérieur : 28 mm - Épaisseur des parois : 2 mm - Diamètre de la bille : 14 mm - Clearance : 0,6 mm Des reliefs internes (“bumps”) ont également été ajoutés afin de modifier le comportement de la bille à l’intérieur de la capsule. L’approche paramétrique présente un intérêt important : elle permet d’adapter facilement les dimensions et les tolérances sans reconstruire entièrement la géométrie. [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/scaled-1680-/d6Eimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/d6Eimage.png) ## 4. Code OpenSCAD Le modèle final est généré à partir du code suivant : ```scad // PRINT-IN-PLACE: Captive ball inside a sealed capsule // The ball is printed inside, separated by a clearance gap, so it moves after printing. $fn = 90; // ---------- Parameters (mm) ---------- capsule_len = 70; capsule_d = 28; wall = 2.0; ball_d = 14; gap = 0.6; bump_d = 4; bump_h = 2.0; bump_count = 6; // ---------- Derived ---------- outer_r = capsule_d/2; inner_r = outer_r - wall; ball_r = ball_d/2; module capsule(r, len){ union(){ translate([0,0,-len/2 + r]) sphere(r); translate([0,0, len/2 - r]) sphere(r); cylinder(r=r, h=len - 2*r, center=true); } } module bumps(){ for(i = [0:bump_count-1]){ angle = 360*i/bump_count; rotate([0,0,angle]) translate([inner_r - bump_h/2, 0, 0]) sphere(d=bump_d); } } module outer_shell(){ capsule(outer_r, capsule_len); } module inner_cavity(){ capsule(inner_r, capsule_len - 2*wall); } module captive_ball(){ sphere(r=ball_r); } union(){ difference(){ outer_shell(); difference(){ inner_cavity(); bumps(); } } captive_ball(); } ``` ## 5. Préparation à l’impression (PrusaSlicer) Le modèle STL généré a été importé dans PrusaSlicer. Les paramètres principaux étaient : - Profil : 0.10 mm FAST DETAIL - Imprimante : Prusa MK4S (nozzle 0.4 mm) - Filament : PLA - Remplissage : 15 % - Temps estimé : environ 1h32 - Filament utilisé : environ 18,5 g Le modèle mesurait environ 70 mm de hauteur pour 28 mm de diamètre, conformément aux paramètres définis dans OpenSCAD. ## 6. Impression et itération La première tentative d’impression a été réalisée en même temps que les objets d’autres étudiants sur le même plateau. Cependant, l’objet d’un camarade s’est détaché pendant l’impression et a interféré avec ma pièce, ce qui a entraîné l’échec du test. Afin d’éviter toute perturbation externe, une seconde impression a été réalisée ultérieurement, seul sur le plateau. Cette seconde tentative s’est déroulée correctement. La capsule a été imprimée sans défaut structurel et la bille interne est restée libre de mouvement après impression, validant ainsi la pertinence de la clearance de 0,6 mm. [![47faa92b-0814-4bb7-883b-9d21d05ed97d-removebg-preview.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/scaled-1680-/4Dr47faa92b-0814-4bb7-883b-9d21d05ed97d-removebg-preview.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/4Dr47faa92b-0814-4bb7-883b-9d21d05ed97d-removebg-preview.png) ## 7. Conclusion Cette séance marque une progression significative par rapport à la précédente. Elle m’a permis de passer d’un simple usage du slicer à une conception paramétrique complète d’un mécanisme fonctionnel. J’ai pu expérimenter concrètement l’importance des tolérances en fabrication additive ainsi que les possibilités offertes par le print-in-place. # Séance 3 – Porte-clé magnétique avec insertion pendant impression [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/scaled-1680-/lLbimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/lLbimage.png) ## 1. Description du projet Ce projet consiste en la modélisation et la fabrication d’un objet simple et fonctionnel intégrant un aimant : un porte-clé magnétique. L’objectif est de créer une pièce compacte capable de se fixer sur des surfaces métalliques tout en conservant une utilisation pratique au quotidien. Contrairement aux séances précédentes, cette pièce nécessite une intervention manuelle pendant l’impression. Une cavité interne est prévue pour accueillir un aimant, qui est inséré au cours du processus avant la fermeture complète de l’objet. Objectifs : - Concevoir un objet fonctionnel simple avec intégration d’un composant externe. - Comprendre et utiliser la technique de pause d’impression. - Adapter la modélisation pour intégrer une cavité interne précise. ## 2. Analyse Technique et Modélisation Afin de contrôler précisément les dimensions de la cavité et garantir un bon ajustement de l’aimant, le modèle a été conçu de manière paramétrique sous OpenSCAD. L’objet est constitué d’un volume cylindrique principal dans lequel une cavité interne est soustraite. Cette cavité est dimensionnée légèrement plus grande que l’aimant afin de faciliter son insertion tout en évitant un jeu excessif. Un trou latéral est également ajouté afin de permettre l’attache à un trousseau de clés. ## 2.1 Concepts Géométriques Le modèle repose sur deux éléments principaux : Le Cylindre (corps principal) : Il constitue la structure externe du porte-clé et assure la rigidité de l’objet. La Cavité interne (logement de l’aimant) : Une soustraction cylindrique permet de créer un espace précis destiné à accueillir l’aimant. Une attention particulière est portée à l’épaisseur des parois supérieures et inférieures afin de garantir la solidité de la pièce tout en permettant la fermeture complète de la cavité après insertion. ## 2.2 Le Code Paramétrique (OpenSCAD) Le script suivant permet de générer automatiquement la géométrie du porte-clé ainsi que la cavité pour l’aimant : ```scad // Magnetic Keychain with Embedded Magnet $fn = 80; // ---------- Parameters ---------- token_diameter = 40; token_height = 8; magnet_diameter = 10.2; magnet_height = 3.2; wall_bottom = 2; wall_top = 2; // ---------- Model ---------- difference() { // Main body cylinder(d = token_diameter, h = token_height); // Magnet cavity translate([0, 0, wall_bottom]) cylinder(d = magnet_diameter, h = magnet_height); // Keychain hole translate([token_diameter/2 - 5, 0, token_height/2]) rotate([90, 0, 0]) cylinder(d = 4, h = token_diameter, center = true); } ``` Caractéristiques du code : - Utilisation de la fonction difference() pour créer la cavité interne. - Paramétrisation complète des dimensions (diamètre, hauteur, aimant). - Intégration d’un trou fonctionnel pour usage réel (porte-clé). ## 3. Fabrication ## 3.1 Paramètres d’Impression (Slicer) Le modèle a été préparé sous PrusaSlicer avec les paramètres suivants : - Imprimante : Prusa MK4 - Matériau : PLA - Buse : 0.4 mm - Hauteur de couche : 0.2 mm - Remplissage (Infill) : 15 % - Supports : Aucun Particularité importante : Une pause a été programmée manuellement dans le slicer à une hauteur correspondant à la fin de la cavité interne. ## 3.2 Procédure d’insertion de l’aimant 1. L’impression commence normalement jusqu’à la hauteur de la cavité. 2. La machine est mise en pause. 3. L’aimant est inséré manuellement dans le logement prévu. 4. L’impression reprend afin de refermer la pièce. Cette étape est essentielle pour intégrer l’aimant sans compromettre la structure du modèle. ## 4. Retours d’expérience Lors de la première tentative, l’insertion de l’aimant nécessitait un bon positionnement afin d’éviter qu’il ne dépasse de la cavité. Analyse : Une tolérance trop faible peut empêcher l’insertion correcte ou provoquer un mauvais alignement. Solution : L’ajout d’un léger jeu (tolérance de +0.2 mm sur le diamètre) permet une insertion plus facile tout en maintenant l’aimant en place. Résultat final : Le porte-clé fonctionne correctement et peut être fixé sur des surfaces métalliques, démontrant l’intégration réussie d’un composant externe dans une pièce imprimée en 3D. ## **Partie Arduino** [Lien ici](https://wiki.fablab.sorbonne-universite.fr/BookStack/books/projets-due-2025-2026/page/toufic-bitar-nina-schwald "Lien ici") # Toufic BITAR - Nina SCHWALD # Séance Arduino – Compte rendu ## **3) Introduction à Arduino** #### **Séance 3 - 16/01/2026** #### **Objectif :** Se familiariser avec la programmation physique à l'aide de circuits électroniques simples. Comprendre comment utiliser le logiciel Arduino IDE et apprendre à programmer des composants électroniques. #### Exercice 1 : ##### **Objectif :** Réaliser un montage pour alimenter une LED et la faire allumer à l'aide d'un programme simple. ##### **Outils :** - Carte Arduino Uno reliée par Câble USB - Planche à pain - LED - Résistances (R) - Fils de connexion - Logiciel Arduino IDE **Le Montage** 1. Connectez pin 12 de l'Arduino à une colonne de la maquette. 2. LED : placez l'anode (longue patte) dans la colonne connectée à pin 12. 3. Connectez la résistance entre la cathode de la LED (patte courte) et la ligne de masse de la maquette. 4. Connectez la broche GND de l'Arduino à cette même ligne de masse.
**Le Code** ```cpp void setup() { pinMode(LED_BUILTIN, OUTPUT); } void loop() { digitalWrite(LED_BUILTIN, HIGH); } ``` ### **Résultat obtenu :** La LED intégrée à la carte Arduino s’allume correctement dès l’exécution du programme. ### **Analyse :** Cet exercice permet de comprendre comment configurer une broche en mode sortie (`OUTPUT`) et envoyer un signal électrique (`HIGH`) pour activer un composant. #### Exercise 2 : ##### Objectif : Modifier le code pour que la LED s'allume et s'éteigne à intervalles réguliers. **Le Code** ```cpp void setup() { pinMode(LED_BUILTIN, OUTPUT); } void loop() { digitalWrite(LED_BUILTIN, HIGH); delay(1000); digitalWrite(LED_BUILTIN, LOW); delay(1000); } ``` ### **Résultat obtenu :** La LED s’allume puis s’éteint toutes les secondes, créant un clignotement régulier. ### **Analyse :** L’utilisation de la fonction `delay()` permet de contrôler la durée entre deux actions. Cependant, cette méthode bloque l’exécution du programme pendant le temps d’attente. #### Exercise 3 : ##### **Objectif :** Modifier le circuit et le code de manière à ce que trois LEDs clignotent à des rythmes différents l'un après l'autre. ##### **Outils :** - Carte Arduino Uno reliée par Câble USB - Planche à pain - 3 LEDs - 3 Résistances (R) - Fils de connexion - Logiciel Arduino IDE **Le Montage** 1. Reliez la broche 13 de l'Arduino à une rangée libre de la maquette. 2. Reliez une résistance de cette rangée à une nouvelle rangée. 3. LED : insérez l'anode (longue patte) dans la nouvelle rangée de la résistance. 4. Connectez la cathode (patte courte) à la barre bleue « - ». 5. Répétez ces quatre étapes pour les broches 12 et 11. 6. Connectez la broche GND de l'Arduino à la barre « - ».
[![CDEDA4D2-D5F3-4E16-B5DA-3DCB09BBBC53_1_105_c.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/scaled-1680-/cdeda4d2-d5f3-4e16-b5da-3dcb09bbbc53-1-105-c.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/cdeda4d2-d5f3-4e16-b5da-3dcb09bbbc53-1-105-c.jpeg) le code: ```cpp int ledBluePin = 13; int ledYellowFirstPin = 12; int ledYellowSecondPin = 11; void setup() { pinMode(ledBluePin, OUTPUT); pinMode(ledYellowFirstPin, OUTPUT); pinMode(ledYellowSecondPin, OUTPUT); } void loop() { digitalWrite(ledBluePin, HIGH); delay(1000); digitalWrite(ledBluePin, LOW); digitalWrite(ledYellowFirstPin, HIGH); delay(1500); digitalWrite(ledYellowFirstPin, LOW); digitalWrite(ledYellowSecondPin, HIGH); delay(2000); digitalWrite(ledYellowSecondPin, LOW); } ``` ### **Résultat obtenu :** Les trois LEDs s’allument successivement avec des durées différentes, créant un effet de séquence lumineuse. ### **Analyse :** Cet exercice permet de comprendre comment gérer plusieurs sorties numériques et appliquer des temporisations différentes à chaque composant. #### Exercise 4 : ##### **Objectif :** Modifier le circuit et le code de manière à ce que trois LED clignotent à des rythmes différents - *mais cette fois-ci indépendamment les unes des autres.* **Le Montage** Comme pour l'exercice 3 *[![B9F3AD4A-6248-4370-AB1D-4571358B5129_1_105_c.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/scaled-1680-/FOJb9f3ad4a-6248-4370-ab1d-4571358b5129-1-105-c.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/FOJb9f3ad4a-6248-4370-ab1d-4571358b5129-1-105-c.jpeg)![F78368DE-14C4-49EC-84B3-29A0994FF494_1_105_c.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/scaled-1680-/f78368de-14c4-49ec-84b3-29a0994ff494-1-105-c.jpeg)*
**Le Code:** ```cpp // Définition des broches utilisées pour les LEDs int ledBluePin = 13; int ledYellowFirstPin = 12; int ledYellowSecondPin = 11; // Emplacements mémoire pour le dernier changement (en millisecondes) unsigned long previousMillisBlue = 0; unsigned long previousMillisYellowFirst = 0; unsigned long previousMillisYellowSecond = 0; // Intervalles de temps (en ms) int intervalBlue = 1000; int intervalYellowFirst = 2000; int intervalYellowSecond = 3000; void setup() { pinMode(ledBluePin, OUTPUT); pinMode(ledYellowFirstPin, OUTPUT); pinMode(ledYellowSecondPin, OUTPUT); } void loop() { unsigned long currentMillis = millis(); // LED bleue if (currentMillis - previousMillisBlue >= intervalBlue) { previousMillisBlue = currentMillis; digitalWrite(ledBluePin, !digitalRead(ledBluePin)); } // 1ère LED jaune if (currentMillis - previousMillisYellowFirst >= intervalYellowFirst) { previousMillisYellowFirst = currentMillis; digitalWrite(ledYellowFirstPin, !digitalRead(ledYellowFirstPin)); } // 2ème LED jaune if (currentMillis - previousMillisYellowSecond >= intervalYellowSecond) { previousMillisYellowSecond = currentMillis; digitalWrite(ledYellowSecondPin, !digitalRead(ledYellowSecondPin)); } } ``` ### **Résultat obtenu :** Les trois LEDs clignotent simultanément mais avec des rythmes différents. ### **Analyse :** Contrairement à `delay()`, la fonction `millis()` permet de gérer plusieurs temporisations en parallèle sans bloquer le programme. Cela rend le système plus efficace et permet de contrôler plusieurs composants en même temps. ## **4) Utilisation d'un capteur** #### **Séance 4 - 30/01/2026** ##### **Objectif :** Utiliser un capteur pour détecter la présence d’un obstacle et contrôler une LED en fonction de cette détection. Construire un circuit et écrire un programme pour utiliser un capteur. La LED doit s'allumer lorsqu'un obstacle se trouve devant le capteur et s'éteindre lorsqu'il n'y en a pas. ##### **Outils** : - Carte Arduino Uno reliée par Câble USB - Planche à pain - LED - Capteur de distance infrarouge - Résistances (R) - Fils de connexion - Logiciel Arduino IDE **Le Montage** 1. Reliez la broche GND de l'Arduino à la rangée bleue « - » de la maquette à l'aide d'un câble. 2. Enfichez la LED bleue sur la maquette. 3. Reliez une extrémité de la résistance à la rangée où se trouve la longue patte de la LED. 4. Insérez l'autre extrémité de la résistance dans une rangée libre. 5. Reliez la broche 13 de l'Arduino à cette extrémité libre de la résistance à l'aide d'un câble. 6. Reliez la rangée de la patte courte de la LED à la barrette bleue « - » à l'aide d'un câble. 7. Reliez la broche GND du capteur à la barrette bleue « - » à l'aide d'un câble. 8. Connectez la broche VCC du capteur directement à la broche 5V de l'Arduino à l'aide d'un câble. 9. Connectez la broche SIG du capteur directement à la broche 2 de l'Arduino à l'aide d'un câble. 10. Connectez l'Arduino à votre ordinateur à l'aide du câble USB. [![1493D980-B728-4EFF-BB47-4EFD6EC4C7F5_1_105_c.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/scaled-1680-/1493d980-b728-4eff-bb47-4efd6ec4c7f5-1-105-c.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/1493d980-b728-4eff-bb47-4efd6ec4c7f5-1-105-c.jpeg)
**Le Code** ```cpp // Définition des broches utilisées pour la LED et le capteur int ledPin = 13; int sensorPin = 2; void setup() { pinMode(ledPin, OUTPUT); pinMode(sensorPin, INPUT); } void loop() { int sensorState = digitalRead(sensorPin); if (sensorState == LOW) { digitalWrite(ledPin, HIGH); } else { digitalWrite(ledPin, LOW); } } ``` ### **Résultat obtenu :** La LED s’allume lorsqu’un obstacle est détecté par le capteur et s’éteint lorsqu’il n’y a pas de détection. ### **Analyse :** Cet exercice permet de comprendre comment utiliser une entrée numérique pour piloter une sortie. Le programme réagit en temps réel aux informations fournies par le capteur. # Stanislas Castella-Soeters M1 Management de l'innovation de l'innovation : 2025 - 2026 --- ##### **Exercice 1 - Impression test : Marque page chat, (16 décembre 2025 - 9 janvier 2026)** Cette impression est une impression test, l'objectif était de se familiariser avec l'impression 3D. Matériel utilisé: - Application PrusaSlicer et Printables - Imprimante 3D Prusa MK4S - Filament PLA noir brillant Je souhaitais imprimer quelque chose d'utile et que je ne possédai pas. L'idée d'un marque page m'a semblé approprié pour une première impression 3D. J'ai donc cherché des modèles de marque page sur Pintables.com. Trois ont retenu mon attention, une épée, les mains d'un monstre et un chat noir. Finalement j'ai imprimé le chat noir, [voici le lien](https://www.printables.com/model/1331558-cat-bookmark) et voici les images extraites du site Pintables: [![Screen Shot 2026-02-06 at 16.10.38.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/screen-shot-2026-02-06-at-16-10-38.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/screen-shot-2026-02-06-at-16-10-38.jpg) *Image 1: Modèle 3D du marque page chat sur Pintables* [![Screen Shot 2026-02-06 at 16.26.08.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/screen-shot-2026-02-06-at-16-26-08.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/screen-shot-2026-02-06-at-16-26-08.jpg) *Image 2: Visualisation du modèle dans PrusaSlicer* ![78973808289__4791FF97-54EF-46F4-B58A-98F40773D9D8.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/78973808289-4791ff97-54ef-46f4-b58a-98f40773d9d8.jpeg)*Image 3: Photographie de mon impression 3D test en action* ##### **Exercice 2 - Impression d'un objet en contenant un autre : Sifflet (** [![IMG_0769.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/img-0769.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/img-0769.jpeg) ##### **Exercice 3 - Impression d'un objet modélisé sur OpenScad : Maracas avec 4 billes (6 Février 2026)** [![Screen Shot 2026-02-06 at 15.04.57.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/hJescreen-shot-2026-02-06-at-15-04-57.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/hJescreen-shot-2026-02-06-at-15-04-57.jpg) ```bash /* [General Settings] */ // Select what to render mode = "view_all"; // [view_all, print_half_1, print_half_2, print_tiny_spheres] /* [Dimensions] */ /* [Détails de la maracas] */ // Longueur total de la maracas (mm) rattle_length = 100; // [80:150] // Diamètre de la sphère de la maracas (mm) head_diameter = 45; // [30:80] // Diamètre de la poignée (mm) handle_diameter = 12; // [8:25] // Épaisseur des parois du maracas (mm). wall_thickness = 2.4; /* [Détails des quatres billes] */ // Number of tiny spheres sphere_count = 4; // Wall thickness for the tiny spheres sphere_wall = 0.8; // Distance to move spheres away from the rattle body sphere_distance_from_body = 20; /* [Detail] */ // Smoothness of the curves $fn = 100; // --- Calculated Values --- tiny_sphere_size = head_diameter / 5; // --- Geometry Modules --- module rattle_body() { // We group the geometry and move it UP so the bottom touches Z=0 translate([0, 0, handle_diameter/2]) union() { // 1. The Hollow Head translate([0, 0, rattle_length - (head_diameter/2)]) difference() { sphere(d = head_diameter); sphere(d = head_diameter - (wall_thickness * 2)); } // 2. The Handle cylinder_height = rattle_length - (head_diameter/2) + 2; translate([0,0,0]) union() { cylinder(h = cylinder_height, d = handle_diameter); // The bottom cap sphere(d = handle_diameter); } } } module tiny_spheres_set() { // Generate the row of spheres for (i = [0 : sphere_count-1]) { // X spacing: diameter + 5mm gap x_pos = i * (tiny_sphere_size + 5); // Z position: Lift up by radius so the bottom touches 0 z_pos = tiny_sphere_size / 2; translate([x_pos, 0, z_pos]) difference() { sphere(d = tiny_sphere_size); sphere(d = tiny_sphere_size - (sphere_wall * 2)); } } } // --- Rendering Logic --- if (mode == "view_all") { // 1. Render the Rattle (Base is at Z=0 inside the module) rattle_body(); // 2. Render the Tiny Spheres // We move them to the right of the rattle head translate([head_diameter/2 + sphere_distance_from_body, 0, 0]) tiny_spheres_set(); } else if (mode == "print_half_1") { // Lay rattle flat for printing (Left Half) rotate([0, 90, 0]) difference() { // We must undo the "standing" translation to rotate it correctly around center translate([0,0,-handle_diameter/2]) rattle_body(); translate([-500, -1000, -500]) cube([1000, 2000, 1000]); } } else if (mode == "print_half_2") { // Lay rattle flat for printing (Right Half) rotate([0, -90, 0]) difference() { translate([0,0,-handle_diameter/2]) rattle_body(); translate([-500, -1000, -500]) cube([1000, 2000, 1000]); } } else if (mode == "print_tiny_spheres") { // Render the spheres sitting on the bed tiny_spheres_set(); } ``` ##### **Exercice 4 - Arduino** # Claire UNG ## **PROJET N°1 : UN POKEMON PAS COMME LES AUTRES - THE GOLDEN NOCTALI** ##### ***(Séance du vendredi 16 décembre 2025)*** ### LA DÉCOUVERTE DE L'IMPRESSION 3D --- **OBJECTIF**** : EXPLORER TOUT LE FONCTIONNEMENT DE L'IMPRESSION 3D ET LES LIMITES EN CREANT UN TOUT PREMIER OBJET AVEC PRUSASLICER ** DESCRIPTION : Pourquoi un Noctali ? Ce choix n'est pas seulement qu'une question de nostalgie. Toutes les formes complexes qu'on retrouve dans mon projet (4 pattes debout, ses oreilles, son fichier d'attente en panache) servent à mieux comprendre et tester toutes les limites de l'imprimante 3D particulièrement les zones de vide et la gravité. #### LES MATÉRIAUX & PARAMETRES D'IMPRESSION : --- - **Matériaux ** : - - Filament PLA (1,75 mm de diamètre) - Imprimante 3D (buse originale Prusa MK4S HF0.4) - **Température du filament** : - - Bus : 230 °C - Plateau : 60 °C - **Supports** : Partout - **Remplissage ** : 15% - **Taille de l'objet** : - - x : 62,55 mm - y : 42,36 mm - z : 50 mm - **Autres réglages** : Par défaut - **Temps d'impression** : 1h15 #### LES DIFFÉRENTES ÉTAPES : --- 1. Ouvrez l'application de PrusaSlicer et cliquez sur Printable 2. Taper sur la barre de recherche Umbreon Pokemon ou [https://www.printables.com/model/181163-umbreonpokemon](https://www.printables.com/model/181163-umbreonpokemon) 3. Cliquer sur Découper ou importer le fichier STL sur PrusaSlicer 4. Ajuster tous les paramètres 5. Découper et exporter le G-code sur une clé USB ### RESULTAT PHOTO - UNE QUALITE AU RENDEZ-VOUS --- [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/LGximage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/LGximage.png) ### L'ANECDOTE DU JOUR - AVEC OU SANS SUPPORT ? --- Pensez-vous qu'une fille qui n'a jamais touché à une imprimante 3D aurait réussi du premier coup un 1er projet ? Figurez-vous que non, loin de là. Une épreuve, un défi, un challenge que mes camarades et moi-même avons tous accepté. Laissez-moi vous présenter les 2 cas de figures de mon projet, mon Noctali Shiny, avec et sans support : - **Sans Support**** : ** N'y pensez même pas. Les pattes de mon Noctali ce jour-là ont été éjectées de la plaque après 15 minutes. Le blanc des yeux de mes camarades qui attendaient derrière moi. Des sourires si longuement échangés et leurs regards semblaient si intenses à ce moment là. Je vous laisse imaginer la scène de l'annonce du recommencement. - **Avec Support** : Après un échec cuisant , qui ferait la même erreur ? Un support posé partout, tout autour de votre Noctali Shiny est le plus recommandé pour garantir une réussite atteignant les 100%. ***(NB : les supports ont été retirés avec succès et sans difficulté) *** ***\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_*** **PROJET N°2 : UNE ROUE D'ATTRACTION MULTIFONTIONNELLE - THE BEYBLADE FERRIS WHEEL** ##### ***(Séance du vendredi 9 janvier 2026)*** ### OPENSCAD LE CODE "FACILE" POUR TOUS ? --- **OBJECTIF**** : CREER UN OBJET QUI N'INCLUT QUE DES FONCTIONS D'OPENSCAD** DESCRIPTION : Pourquoi une roue ? Un vrai défi que je me suis lancé. Au début j'avais pensé à créer une roue de fête foraine mais elle peut très bien faire l'affaire en tant que toupie. Avec cette roue je pouvais tester de nombreuses fonctions comme des cylindres, des cercles, des cubes, soustraire etc. #### LES MATÉRIAUX & PARAMETRES D'IMPRESSION : --- - **Matériaux ** : - - Filament PLA (1,75 mm de diamètre) - Imprimante 3D (buse originale Prusa MK4S HF0.4) - Application : OpenScad - **Température du filament** : - - Bus : 230 °C - Plateau : 60 °C - **Supports** : Partout - **Remplissage ** : 15% - **Taille de l'objet** : - - x : 71,25 mm - y : 71,25 mm - z : 15 mm - **Autres réglages** : Par défaut - **Temps d'impression** : 1h30 #### LES DIFFÉRENTES ÉTAPES : --- 1. Coder sur OpenScad 2. Cliquez sur exporter en fichier STL 3. Sur Prusa Slicer, cliquez sur importer le fichier STL 4. Ajuster tous les paramètres 5. Découper et exporter le G-code sur une clé USB #### CODAGE : --- ```c++ // GRANDE ROUE D'ATTRACTION $fn = 50; // ARRONDISSEMENT DE MES CERCLES // STRUCTURE PRINCIPALE rayon_roue = 40; epaisseur_roue = 5; nb_rayons = 12; nb_cabines = 12; taille_cabine = 15; // LA ROUE module roue() { difference() { // disque principal cylinder(h=epaisseur_roue, r=rayon_roue, center=true); // trou central cylinder(h=epaisseur_roue+1, r=30, center=true); } } // RAYONS module rayons() { for (i = [0 : 360/nb_rayons : 360-360/nb_rayons]) { rotate([0,0,i]) translate([rayon_roue/2,0,0]) cube([rayon_roue,2,epaisseur_roue], center=true); } } // CABINE module cabine() { //TROU DES CABINES ET DESIGN difference() { cube([taille_cabine, taille_cabine, taille_cabine], center=true); // EPAISSEUR DES PAROIS translate([0,0,2]) cube([taille_cabine-2, taille_cabine-2, taille_cabine], center=true); } } // LES 12 CABINES RÉPÉTÉES module cabines() { for (i = [0 : 360/nb_cabines : 360-360/nb_cabines]) { rotate([0,0,i]) translate([rayon_roue,0,0]) cabine(); } } // LE ROND CENTRAL module axe() { cylinder(h=20, r=5, center=true); } // ASSEMBLAGE FINAL union() { roue(); rayons(); axe(); cabines(); } ``` ### PHOTOS DU RÉSULTAT - UNE ROUE EN OR --- [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/jbVimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/jbVimage.png) ### L'ANECDOTE DU JOUR - UN SUPPORT INDESTRUCTIBLE ?! --- Après 1h30 d'attente, le résultat est impeccable à condition que je réussisse à retirer tous les supports que j'ai posé tout autour de ma roue. Selon vous quel problème j'ai pu rencontrer ? Mes supports étaient à ce moment là plus durs et plus solides que l’objet en lui-même . Une pierre d'une résistance sans appel, je n'ai jamais prévu un tel rebondissement. Mon 1er réflexe était de le refaire mon objet sans support. - **Un Essai Sans Support**** : ** Pensez-vous que cela pouvait fonctionner ? Qui ne tente rien n'a rien. J'y croyais de toutes mes forces, avec espoir, avec toute ma confiance, mais non. - **Solution** : User d'une pince et faire preuve de patience. Garder, patience après tout un codage. Garder patience, après une attente d'1h30. Garder patience, dans la retraite de tout un support difficile à retirer. Cela m'a pris 1h ou plus pour obtenir un résultat lisse et impeccable. Si je dois reprendre toute ma séance en un seul mot :** PATIENCE** . ***(NB : Vérifier la taille de l'épaisseur est une bonne idée) *** ***\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_*** ## **Projet N°3 : OUVREZ LES TOUS AVEC LE GUN CAN OPENER !** ##### ***(Séance du vendredi 16 janvier 2026)*** ### UN SAVOIR, UN ASSEMBLAGE --- **OBJECTIF**** : CREER UN OBJET DONT LA DIMENSION EST IMPORTANTE PENSEE POUR INTERAGIR AVEC UN AUTRE OBJET EXISTANT EN S'Y ADAPTANT PARFAITEMENT** DESCRIPTION : Pourquoi un ouvre-boite cannette ? Cet ouvre-boîte n’est pas qu’un outil. Tout est pensé pour s’adapter parfaitement à une cannette, pour que le geste d’ouvrir devienne naturel, presque instinctif. Avec ce projet, l’impression 3D n’est plus juste une technique : elle devient un moyen de créer un objet vivant, où chaque détail compte, où chaque forme a sa raison d’être pour que la fonction s’accomplisse avec justesse. #### LES MATÉRIAUX & PARAMETRES D'IMPRESSION : --- - **Matériaux ** : - - Filament PLA (1,75 mm de diamètre) - Imprimante 3D (buse originale Prusa MK4S HF0.4) - Application : Prusa Slicer, OpenScad - **Température du filament** : - - Bus : 230 °C - Plateau : 60 °C - **Supports** : Partout - **Remplissage ** : 15% - **Taille de l'objet** : - - x : 206,66 mm - y: 200,83 mm - z : 83,1 mm - **Autres réglages** : Par défaut - **Temps d'impression** : 6 h #### LES DIFFÉRENTES ÉTAPES : --- 1. Ouvrez l'application de PrusaSlicer et cliquez sur Printabl[![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/A83image.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/A83image.png)e 2. Taper sur la barre de recherche gun can opener ou [https://www.printables.com/model/1480263-gun-can-opener](https://www.printables.com/model/1480263-gun-can-opener) 3. Cliquer sur Découper ou importer le fichier STL sur PrusaSlicer 4. **IMPORTANT : GARDER LA MEME TAILLE POUR L'OBJET ON NE TOUCHE A RIEN !!** 5. Découper et exporter le G-code sur une clé USB ### PHOTOS DU RÉSULTAT & VIDEO DE L'ASSEMBLAGE - SOMETIMES IS TOO SLOW, FOR SURE --- [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/PJGimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/PJGimage.png) ### L'ANECDOTE DU JOUR - IT NEEDS TO BE REDONE, FOR SURE --- ![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/eYbimage.png) Après 6h d'attente, La question que vous pouvez vous demander est comment j'ai pu en arriver là ? Si je devais lister : 1. Il peut arriver que vous vous rendez compte en plein milieu, qu'il n'y a pas suffisamment de filament PLA pour terminer votre objet. Pas de panique ! **Solution** : Mettez l’imprimante en pause, remplacer le filament, puis de relancer l’impression. Cette manipulation n’affecte ni la poursuite, ni la qualité de l’objet en cours d’impression. Soyez rassuré et cela fera un objet unique et multicolore ! 2. On peut rencontrer ce problème : repérer les supports et les retirer de manière rigoureux. Ici, ce n'est pas le cas. **Solution** : Il est toujours bien de revoir sur votre ordi la longueur que vous avez mis initialement pour vos supports pour éviter ce résultat. Il suffit d'un manque d'attention pour au final recommencer à refaire votre objet. **Solution** : Recommencer à réimprimer l'objet défectueux Et pour l'assemblage je n'ai pas rencontrer de problèmes, et tout fonctionne !! ***(NB : Pour la vis, vérifiez que la tête soit fine sinon cela ne rentrera jamais ) *** \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ #### Voir aussi : **[PROJET PROTOTYPAGE ARDUINO - Jacques YE, Claire UNG](https://wiki.fablab.sorbonne-universite.fr/BookStack/books/projets-due-2025-2026/page/projet-prototypage-arduino-jacques-ye-claire-ung "PROJET PROTOTYPAGE ARDUINO - Jacques YE, Claire UNG")** # Bence Marton - Projets ## **Marque Page Chat - 09/01/2026** ##### **Coordonées** Bence Marton, martonbence9@gmail.com, Master Management de l'Innovation. ### **Introduction** Fait le 09/01/2026. Afin de me familiariser avec les techniques d'impression 3D, je vais imprimer le marque page suivant: ![peeking_cat1.webp](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/peeking-cat1.webp) ### **Outils** Printables.com; PrusaSlicer 2.5.0; ### **Construction** - J'ai trouvé un modéle sur le site printables.com que j'ai bien aimé (URL = [https://www.printables.com/model/346623-peeking-cat-bookmark-3d)](https://www.printables.com/model/346623-peeking-cat-bookmark-3d)). [![Capture.PNG](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/capture.PNG)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/capture.PNG) - J'ai ouvert les deux fichier avec PrusaSlicer 2.5.0: [![Screenshot 2026-01-09 at 15.03.14.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/screenshot-2026-01-09-at-15-03-14.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/screenshot-2026-01-09-at-15-03-14.png) - J'ai séparé les deux objets en clickant et glissant l'objet: [![Screenshot 2026-01-09 at 15.06.20.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/screenshot-2026-01-09-at-15-06-20.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/screenshot-2026-01-09-at-15-06-20.png) - Voici les paramètres de l'impression: [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/uU0image.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/uU0image.png) - J'ai exporté le G-Code sur une clé USB et je l'ai inséré dans une machine à l'impression 3D. J'ai choisi le nom de mon fichier sur la console de l'imprimante et l'ai démarré. Aprés 30 mins l'impression est terminé: [![Screenshot 2026-01-09 at 15.24.17.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/screenshot-2026-01-09-at-15-24-17.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/screenshot-2026-01-09-at-15-24-17.png) - Ensuite j'ai dû mettre les deux objets ensemble et les coller avec de la colle instantanée pour avoir l'objet final : [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/Uwximage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/Uwximage.png) ───────────────────────────────────────────────────────── ## **Microbot Fidget - 14/01/2026** ### **Introduction** Fait le 09/01/2026. Un projet plus complexe, imprimer un fidget détachable: **[![Screenshot 2026-01-14 at 17.24.16.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/screenshot-2026-01-14-at-17-24-16.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/screenshot-2026-01-14-at-17-24-16.png)** ### **Outils** Printables.com; PrusaSlicer 2.5.0; ### **Construction** - J'ai trouvé un modéle sur le site printables.com que j'ai bien aimé (URL = [https://www.printables.com/model/234913-microbot-fidget)](https://www.printables.com/model/234913-microbot-fidget)) [![Screenshot 2026-01-14 at 17.28.04.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/screenshot-2026-01-14-at-17-28-04.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/screenshot-2026-01-14-at-17-28-04.png) - J'ai ré-crée le modèle en openSCAD á l'aide de IA (j'ai fourni les fichiers STL, le G-code et une description). J'ai dû affiner et corriger certaines parties du code pour qu'il fonctionne. [![IMG_8293.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/img-8293.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/img-8293.jpeg) ``` /* Microbot Fidget - Data-Driven Recreation Calibrated from: microbot(2).stl & G-code metadata */ $fn = 64; // --- Calibrated Parameters --- base_width = 15.0; // Derived from G-code polygon base_depth = 12.0; top_width = 8.0; limb_height = 20.0; // Individual segment height ball_radius = 5.2; // Calibrated joint size joint_clearance = 0.25; // Standard snap-fit tolerance slit_width = 0.8; // Optimized for 0.4mm nozzle [cite: 530] // --- Layout --- translate([-15, 0, 0]) male_segment(); translate([15, 0, 0]) female_segment(); module body_geometry() { // Tapered hexagonal/rounded body hull() { // Bottom Plate linear_extrude(1) offset(r=2) square([base_width-4, base_depth-4], center=true); // Neck Plate translate([0,0,limb_height]) linear_extrude(1) offset(r=1) square([top_width-2, top_width-2], center=true); } } module male_segment() { union() { body_geometry(); // Ball Stem translate([0,0,limb_height]) cylinder(h=ball_radius, r1=top_width/2, r2=ball_radius-1); // The Joint Ball translate([0,0,limb_height + ball_radius + 1]) sphere(r=ball_radius); } } module female_segment() { difference() { union() { body_geometry(); // Socket Housing translate([0,0,limb_height]) cylinder(h=ball_radius*2.2, r=ball_radius + 1.8); } // Sphere Cavity translate([0,0,limb_height + ball_radius + 1]) sphere(r=ball_radius + joint_clearance); // Entry Hole (allows snap-in) translate([0,0,limb_height + ball_radius*2]) cylinder(h=ball_radius, r1=ball_radius-1, r2=ball_radius+1); // Stress Relief Slits (for flexibility) translate([0,0,limb_height + ball_radius + 1]) cube([slit_width, (ball_radius+2)*2.5, ball_radius*3], center=true); translate([0,0,limb_height + ball_radius + 1]) cube([(ball_radius+2)*2.5, slit_width, ball_radius*3], center=true); } } ``` - J'ai téléchargé les documents en .STL puis je les ai ouvert avec PrusaSlicer. J'ai allongé la pièce qui était debout puis j'ai sélectionné les paramètres suivantes: - 0.20mm Speed - Generic PLA - Avec un densité de 50% - Support: for support enforcers only - J'ai exporté le G-Code et j'ai imprimé. J'ai obtenu les trois piéces suivant que j'ai collé ensembe à l'aide des peinces et du colle instantané. [![IMG_7949.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/img-7949.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/img-7949.jpeg)[![IMG_7951.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/img-7951.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/img-7951.jpeg) ───────────────────────────────────────────────────────── ## **Partie Arduino /w Kristina & Demir** **--› [Lien ici](https://wiki.fablab.sorbonne-universite.fr/BookStack/books/projets-due-2025-2026/page/kristina-bence-demir-partie-arduino)** # Mélissa Marty ### **Modèle de documentation à remplir** #### **Nom du projet : Puppy pot** **Coordonnées :** - **Nom / Prénom :** Marty Mélissa - **Adresse mail :** Melissa.Marty@etu.sorbonne-universite.fr - **Cursus :** Master 1 Management de l’innovation **Introduction** - **Date de début :** 14/01/2026 - **Date de fin estimée :** 14/01/2026 - **Objectifs :** Découvrir le logiciel PrusaSlicer, apprendre à paramétrer un fichier G-code et préparer l'impression d'un objet complexe/utile. - **Contexte :** Première séance de prise en main des machines du Fablab et choix d'un modèle sur Printables. **Matériaux / Outils / Machines** - **Logiciels :** PrusaSlicer (pour le découpage/slicing) - **Plateforme :** Printables (pour trouver le modèle 3D) - **Imprimante prévue :** Imprimante FDM (type Prusa i3 MK3S+ ou MK4) - **Matériau prévu :** PLA (Diamètre 1,75 mm) - **Outils de finition :** Spatule (pour le décollage futur) ##### **-> Première séance du vendredi 16 décembre 2025 :** Découverte des outils à impression 3D (PrusaSlicer) Séance découverte de l'usage de l'impression 3D et de comment imprimer des modèles. Découverte du logiciel PrusaSlicer et importation d'un objet via printable du logiciel 3D afin d'imprimer un objet. L’objectif de la première séance était de découvrir le FABLAB et les bases de l’impression 3D à travers le logiciel PrusaSlicer et les imprimantes Prusa MK4S. Pour cette toute première impression, j’ai choisi d’imprimer un objet qui représente un chien accroché à un pot à partir d’un fichier STL disponible directement sur le site web printables.com. [![Une image contenant texte, capture d’écran, Police Le contenu généré par l’IA peut être incorrect.](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/embedded-image-qspyrgki.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/cOXimage.png) Voici le modèle que j’ai choisi sur le site printables.com : **![Une image contenant capture d’écran, texte, Site web Le contenu généré par l’IA peut être incorrect.](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/embedded-image-iwqgpji0.png)** **Note importante :** J’ai ensuite importer le fichier STL sur PrusaSlicer afin de modifier et d’ajuster les paramètres tels que la taille et le temps d’impression, puis j’ai exporter le fichier en G code pour débuter l’impression. **Paramètres de l’objet : **J'ai modifié les paramètres avec les dimensions que je souhaitais ![Une image contenant texte, capture d’écran, Police, nombre Le contenu généré par l’IA peut être incorrect.](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/embedded-image-fcr3omj0.png) **Visualisation avant impression : ** **![Une image contenant capture d’écran, Logiciel de graphisme, Logiciel multimédia, texte Le contenu généré par l’IA peut être incorrect.](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/embedded-image-8qxwyojk.png)** **Résultat :** **![Une image contenant intérieur, céramique, bol, sol Le contenu généré par l’IA peut être incorrect.](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/embedded-image-jil9igyn.jpeg) ![Une image contenant intérieur, céramique, chien, Silhouette d’animal Le contenu généré par l’IA peut être incorrect.](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/embedded-image-nmw7xkls.jpeg)** **Analyse de l’objet après impression :** On observe une difficulté de post-traitement au niveau de la face inférieure. Les structures de support présentent une adhérence excessive à la pièce, rendant leur retrait manuel incomplet sans risquer d'endommager l'état de surface de l'objet. De plus, sous l'oreille du chien, on note un léger affaissement de la matière. Ce défaut esthétique est lié à une zone en surplomb trop importante où le filament a refroidi dans le vide avant de se fixer, créant des résidus de matière difficiles à extraire. Enfin, on observe qu’à l'intérieur du pot, l'état de surface n'est pas parfaitement lisse. On constate des artefacts d'impression sous forme de vagues. Cela est généralement dû aux vibrations mécaniques de l'imprimante lors des changements de direction rapides de la tête d'impression. **Journal de bord résumé : ** **14/01/2026 :** 1. Navigation sur la plateforme **Printables** intégrée à PrusaSlicer. 2. Sélection du fichier STL et importation dans le logiciel. 3. Configuration des paramètres (remplissage, supports et type de filament). 4. Génération du **G-code** (découpage des couches). 5. Visualisation du temps d'impression estimé 6. Enregistrement sur clé USB pour la prochaine session. **Conclusion :** Cette étape m'a permis de comprendre que la préparation logicielle est aussi importante que l'impression elle-même. J'ai pu observer comment les couches se sont superposer au cours de l’impression. ##### **-> Deuxième séance du 9 janvier 2026 :** **Contexte :** Dans le cadre de l'UE Processus d'Innovation, nous devons concevoir un objet plus "compliqué" à coder et à imprimer. **Objectifs :** - Concevoir un magnet en forme de patte de chien - Approfondir le processus de création d’un objet en impression 3D - Utiliser un logiciel de modélisation 3D ![Une image contenant dessin humoristique Le contenu généré par l’IA peut être incorrect.](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/embedded-image-ze2bkobq.png) **Conception détaillée et intégration fonctionnelle :** **1. Modélisation et personnalisation avec logiciel Tinkercad :** Le design de la patte de chien a été personnalisé avec deux fonctionnalités spécifiques : - **Gravure débouchante :** Le texte "CODY" a été intégré en utilisant une fonction de retrait de matière (perçage). Les lettres sont extrudées négativement à travers la pièce, créant un lettrage ajouré. - **Logement pour aimant :** À l'arrière de l'objet, j'ai conçu une cavité circulaire destinée à recevoir un aimant. **2. Métrologie et ajustement :** Pour garantir l'insertion de l'aimant, j'ai procédé à une étape de métrologie : - **Mesure précise :** À l'aide d'un pied à coulisse, l'aimant a été mesuré avec une précision au centième (diamètre de **8,04 mm** et épaisseur de **1,29 mm**). - **Gestion des tolérances :** Pour que l'aimant rentre bien dans son emplacement, j'ai fait le trou un peu plus large sur Tinkercad (environ 0.1 ou 0.2 mm de plus). C’est ce qu’on appelle une marge de sécurité (ou tolérance). En effet, à l'impression, le plastique a tendance à s'étaler un peu ou à rétrécir en refroidissant. Sans cette marge, le trou aurait été trop petit et l'aimant n'aurait pas pu rentrer. ![Une image contenant intérieur, outil, Appareils électroniques, machine Le contenu généré par l’IA peut être incorrect.](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/embedded-image-xgjc4og5.png)![Une image contenant appareil, étrier, balance, intérieur Le contenu généré par l’IA peut être incorrect.](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/embedded-image-prrjia9b.jpeg) **Phase de préparation et impression (Slicing) :** **1.** **Importation et configuration :** Après avoir exporté mon design de Tinkercad au format STL, je l'ai importé dans le logiciel PrusaSlicer. J'ai ajusté les paramètres de remplissage et la hauteur des couches pour assurer la solidité de la patte de chien. ![Une image contenant capture d’écran, Logiciel multimédia, texte, Logiciel de graphisme Le contenu généré par l’IA peut être incorrect.](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/embedded-image-fyhsrpkr.png) **2. Insertion de l'aimant (Pause programmée) :** Pour que l'aimant soit totalement intégré à l'intérieur de la pièce, j'ai utilisé une fonction spécifique dans le logiciel de découpe : - Grâce à la barre de visualisation des couches (à droite de l'écran), j'ai repéré la hauteur exacte où le trou de l'aimant allait être recouvert par la couche suivante. - J'ai ajouté une **pause de l'impression** à ce niveau précis. - **Pendant l'impression :** La machine s'est arrêtée toute seule et a déplacé la buse sur le côté. J'ai alors pu déposer l'aimant dans son logement. - **Finalisation :** J'ai relancé l'impression, et l'imprimante a "fermé" le trou en imprimant par-dessus l'aimant, le rendant ainsi invisible et parfaitement prisonnier de la pièce. ![Une image contenant capture d’écran, Logiciel multimédia, texte Le contenu généré par l’IA peut être incorrect.](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/embedded-image-c1elzisq.png) ![Une image contenant texte, capture d’écran, affichage, nombre Le contenu généré par l’IA peut être incorrect.](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/embedded-image-al9a685w.png) **Analyse de l'échec et itération :** **1. Premier essai : Défaut de solidité et d'adhérence.** La première impression a échoué car la pièce manquait de solidité. Le remplissage (infill) n'était pas assez dense, ce qui a entraîné une mauvaise liaison entre les couches de plastique. De plus, la pièce n'était pas assez stable sur le plateau, provoquant un défaut au moment de la reprise après la pause. **2. Analyse de la cause :** J'ai identifié que le problème venait de deux facteurs techniques : - **Un remplissage trop faible :** Les parois n'avaient pas assez de support interne pour lier correctement les couches entre elles. - **Un manque d'adhérence au plateau :** La base de la pièce n'était pas assez maintenue pour supporter les manipulations lors de l'insertion de l'aimant. ![Une image contenant personne, art, intérieur, ciseaux Le contenu généré par l’IA peut être incorrect.](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/embedded-image-ob7ocrpc.png)![Une image contenant machine Le contenu généré par l’IA peut être incorrect.](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/embedded-image-4kg2rpxu.jpeg)![Une image contenant art, sol Le contenu généré par l’IA peut être incorrect.](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/embedded-image-iapzlhox.jpeg)![Une image contenant bleu, sol Le contenu généré par l’IA peut être incorrect.](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/embedded-image-95bseasp.jpeg) **3. Deuxième essai et résolution :** Pour la seconde impression, j'ai modifié mes paramètres sur PrusaSlicer pour corriger ces défauts : - **Augmentation du remplissage :** J'ai choisi un taux plus élevé pour renforcer la structure interne et améliorer la liaison entre les couches. - **Ajout d'un "Radeau" (Raft) :** J'ai ajouté **deux couches de radeau** (une base de plastique imprimée sous la pièce). Cela a permis d'augmenter la surface de contact avec le plateau et de garantir que la pièce reste parfaitement immobile. **Résultat :** Ces corrections ont parfaitement fonctionné. La pièce est solide, l'aimant est bien emprisonné, et il fonctionne parfaitement à travers le plastique. ![Une image contenant sol, intérieur, bleu, en bois Le contenu généré par l’IA peut être incorrect.](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/embedded-image-2tbwtjd5.jpeg) L'aimantation fonctionne parfaitement à travers la fine couche de plastique supérieure, remplissant ainsi totalement l'objectif fonctionnel de l'objet. ![Une image contenant bleu, intérieur Le contenu généré par l’IA peut être incorrect.](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/embedded-image-vaik2ane.jpeg) ##### **->** **Troisième séance du 16 janvier 2026 :** Séance d’électronique (avec Sarah AOUCHICHE et Selma SALBAS) La suite des séances avaient pour but de découvrir le prototypage en utilisant les cartes Arduino. Plateforme expérimentale : Arduino Matériel principal : Arduino Uno **1. INTRODUCTION** Cette séance vise l’appropriation d’une plateforme de prototypage microcontrôlée par la mise en œuvre progressive de fonctions fondamentales des systèmes embarqués : génération de sorties numériques, gestion temporelle de l’exécution et interaction capteur–actionneur via acquisition analogique. **Premier prototype :** L’objectif est de mettre en œuvre une sortie logique afin de caractériser la commutation de potentiel sur une broche numérique et sa traduction en signal lumineux. **Dispositif** - Carte Arduino Uno - LED intégrée (broche numérique 13) - Environnement Arduino IDE **Code** void setup() { pinMode(LED\_BUILTIN, OUTPUT); } void loop() { digitalWrite(LED\_BUILTIN, HIGH); delay(1000); digitalWrite(LED\_BUILTIN, LOW); delay(1000); } **Modèle de fonctionnement** La broche associée à LED\_BUILTIN est configurée en sortie. La boucle principale génère une onde carrée de période 2 s par alternance HIGH/LOW, correspondant à une commutation entre ~5 V et 0 V. **Observation** La LED présente un clignotement périodique stable, validant la correspondance entre état logique et émission lumineuse. [![IMG_2881.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/img-2881.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/img-2881.jpeg) **Deuxième prototype :** **Dispositif** - Carte Arduino Uno - Deux LED externes - Deux résistances de limitation de courant - Breadboard **Code** void setup() { pinMode(13, OUTPUT); pinMode(12, OUTPUT); } void loop() { digitalWrite(13, HIGH); delay(2000); digitalWrite(13, LOW); digitalWrite(12, HIGH); delay(1000); digitalWrite(12, LOW); delay(500); } Les deux LED ne clignotent pas de manière indépendante. Le programme exécute les instructions l’une après l’autre à cause de la fonction delay(), ce qui impose un fonctionnement séquentiel. **Observation :** - Le contrôle de plusieurs LED fonctionne correctement. - Les délais bloquent l’exécution du programme pendant leur durée. - Cela montre la limite de cette méthode pour contrôler plusieurs actions en même temps. [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/cxvimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/cxvimage.png) **Prototype 3 :** L’objectif est de mettre en œuvre une chaîne d’acquisition analogique et utiliser une grandeur physique (luminosité) comme variable de décision pour le pilotage d’une LED. **Dispositif** - Carte Arduino Uno - Photo-résistance (LDR) - Résistance de référence (pont diviseur de tension) - LED + résistance - Breadboard **Principe** - Lecture analogique de la tension issue du capteur - Comparaison à un seuil expérimental - Activation ou désactivation de la LED selon la condition lumineuse **Code** int capteur = A0; // entrée analogique de la photorésistance int led = 13; // LED (interne ou externe) int seuil = 500; // seuil de luminosité (à ajuster) void setup() { pinMode(led, OUTPUT); Serial.begin(9600); // pour voir les valeurs mesurées } void loop() { int valeur = analogRead(capteur); // lecture du capteur Serial.println(valeur); if (valeur < seuil) { digitalWrite(led, HIGH); // sombre → LED allumée } else { digitalWrite(led, LOW); // lumineux → LED éteinte } delay(200); } **Observation** La variation d’éclairement modifie continûment la valeur mesurée ; la LED change d’état lorsque le seuil est franchi, établissant une boucle perception–décision–action. [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/P2Yimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/P2Yimage.png) Les résultats obtenus lors de ces exercices mettent en évidence la correspondance entre modèle logiciel et comportement matériel. L’usage de temporisations bloquantes simplifie l’implémentation mais limite l’indépendance temporelle des actionneurs. L’intégration d’un capteur analogique démontre la capacité du système à fermer une boucle de contrôle élémentaire dépendante de l’environnement. # Projet Gaspard SCHMITT # **Conception et Impression 3d d'objets en lien avec mon projet** #### Informations - Gaspard SCHMITT - gaspard.schmitt@etu.sorbonne-universite.fr - Master management de l'innovation - 16/12/2025 - 30/03/2026 ### **1er Objectif :** ##### Imprimer un dé à coudre sur mesure pour protéger les doigts lors de la couture des parois épaisses de la housse pour notre projet **Sleave** (housse d'ordinateur avec batterie intégré). ### Etape 1 : Conception du dé à coudre sur OpenScad Pour cette première phase de conception, j'ai décidé d'utiliser Claude (un des LLM les plus performant en génération de code selon moi) pour produire le script de base en langage **OpenSCAD**. En utilisant un **prompt engineering** précis autour de contraintes techniques spécifiques (diamètre du doigt, épaisseur des parois, profondeur des alvéoles), j'ai obtenu rapidement une base paramétrique fonctionnelle, sans passer par les nombreux allers-retours de débogage qu'aurait impliqué un codage manuel. J'ai ensuite affiné les dimensions paramètre par paramètre pour adapter le modèle exactement à mon doigt. #### Prompt : ``` Tu es un expert en modélisation 3D paramétrique avec OpenSCAD. Génère-moi le script complet pour un dé à coudre sur mesure avec les contraintes suivantes : Diamètre intérieur : 18 mm (pour s'adapter à mon doigt) Hauteur totale : 25 mm Épaisseur des parois : 1,5 mm Fond fermé, ouverture en haut Alvéoles hémisphériques répartis uniformément sur toute la surface extérieure (diamètre alvéole : 2 mm, profondeur : 1 mm) Légère conicité vers le haut pour faciliter l'enfilage Tolérance d'impression FDM : +0,3 mm sur le diamètre intérieur Le script doit être entièrement paramétrique (toutes les dimensions en variables en tête de fichier) pour pouvoir ajuster facilement. Ajoute des commentaires pour chaque section du code. ``` #### Code : ``` // Dé à coudre lisse - creux - sommet arrondi (robuste) $fn = 120; // Dimensions (mm) inner_d = 17.0; height = 27.0; wall = 2.2; top_th = 2.2; taper = 1.2; // Arrondi du haut (valeur demandée) round_r_wanted = 2.5; // --- Calcul automatique d'un arrondi maximum "safe" --- outer_d = inner_d + 2*wall; r_top_outer = (outer_d/2) - taper; // On garde une marge pour éviter les rayons nuls/négatifs round_r = min(round_r_wanted, r_top_outer - 0.4); module outer_shell_rounded(){ // cœur avant Minkowski (doit rester positif) core_h = height - round_r; r1_core = outer_d/2 - round_r; r2_core = (outer_d/2 - taper) - round_r; intersection() { minkowski() { cylinder(h=core_h, r1=r1_core, r2=r2_core); sphere(r=round_r); } // base plane (on coupe sous z=0) translate([-200,-200,0]) cube([400,400,400]); } } module thimble(){ difference(){ outer_shell_rounded(); // cavité intérieure (ouverte en bas, toit en haut) cylinder( h = height - top_th, r1 = inner_d/2, r2 = inner_d/2 - taper*0.85 ); } } thimble(); ``` ##### **Visualisation sur OpenScad :** [![Capture d'écran 2026-01-16 003722.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/capture-decran-2026-01-16-003722.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/capture-decran-2026-01-16-003722.png) ### Etape 2 : Importation et configuration sur PrusaSlicer Une fois le fichier `.stl` généré, je l'ai transféré dans le logiciel de **slicing PrusaSlicer**. Cette étape me permet de traduire la vision théorique en un objet physique. J'ai dû configurer les paramètres d'impression pour garantir la solidité du dé : - **Buse :** 200°C - **Plateau** : 60°C - **Diamètre du filament:** PLA, 1,75 mm - **Remplissage** : 20 % mais idéalement plus pour une meilleure résistance à l'aiguille - **Paramètres d'impression :** paramètres par défaut de PrusaSlicer (qualité standard, épaisseur de couche 0.15mm pour plus de précision sur les alvéoles) [![Capture d'écran 2026-01-16 004215.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/capture-decran-2026-01-16-004215.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/capture-decran-2026-01-16-004215.png) ### Étape 3 : Vérification finale et exportation en G-code Pour cette avant dernière étape, j'ai juste vérifier la simulation de l'impression (couche par couche) directement dans l'interface du logiciel et procédé à l'exportation du fichier au format **G-code**. **Ce fichier est extrêmement important car il contient l'ensemble des instructions numériques destinées à piloter l'imprimante 3D.** ### Étape 4 : Passons à l'impression [![IMG_6371.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/img-6371.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/img-6371.jpeg) ### Objet fonctionnel : Dé à coudre adapté à mon doigts [![IMG_6372.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/Jdpimg-6372.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/Jdpimg-6372.jpeg) ### **2ème Objectif :** ##### Concevoir un cutter avec système de fermeture pour la fabrication de notre prototype de la housse Sleave. ### Etape 1 : Conception d'un cutter avec système de fermeture Pour concevoir le modèle du cutter, plutôt que de concevoir ce deuxième objet de zéro, j'ai exploré le hub de modèles intégré à PrusaSlicer pour trouver une base existante adaptée ce que je recherchais. Mon approche est une autre façon d'utiliser les outils numériques de fabrication : utiliser l'expérience communautaire. J'ai sélectionné un modèle de cutter avec capuchon qui correspondant aux dimensions de ma lame, puis vérifié sa compatibilité dimensionnelle avant de l'importer directement dans PrusaSlicer pour le slicing. ### Étape 2 : Importation et configuration sur PrusaSlicer Après avoir disposer toutes les pièces à imprimer pour mon cutter sur le plateau du simulateur de puraslicer de manière à ce que la buse ne s'emmèle en touchnat les autres pièces, j'ai repris les mêmes configs que pour le dé : - **Buse :** 200°C - **Plateau** : 60°C - **Diamètre du filament:** PLA, 1,75 mm - **Remplissage** : 20 % - **Paramètres d'impression :** paramètres par défaut de PrusaSlicer (qualité standard, épaisseur de couche 0.15mm pour plus de précision sur les alvéoles) ### Étape 3 : Passons à l'impression [![WhatsApp Image 2026-03-24 at 00.07.09 (1).jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/scaled-1680-/VSmwhatsapp-image-2026-03-24-at-00-07-09-1.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/VSmwhatsapp-image-2026-03-24-at-00-07-09-1.jpeg) ### Objet fonctionnel : Cutter avec système de fermeture [![WhatsApp Image 2026-03-24 at 00.07.09 (2).jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/scaled-1680-/acxwhatsapp-image-2026-03-24-at-00-07-09-2.jpeg) ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/acxwhatsapp-image-2026-03-24-at-00-07-09-2.jpeg)[![WhatsApp Image 2026-03-24 at 00.07.09 (5).jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/scaled-1680-/gV0whatsapp-image-2026-03-24-at-00-07-09-5.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/gV0whatsapp-image-2026-03-24-at-00-07-09-5.jpeg) [![WhatsApp Image 2026-03-24 at 00.07.09 (6).jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/scaled-1680-/35Jwhatsapp-image-2026-03-24-at-00-07-09-6.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/35Jwhatsapp-image-2026-03-24-at-00-07-09-6.jpeg)[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/whatsapp-image-2026-03-24-at-00-07-09-6.jpeg)[![WhatsApp Image 2026-03-24 at 00.07.09 (7).jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/scaled-1680-/RLuwhatsapp-image-2026-03-24-at-00-07-09-7.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-03/RLuwhatsapp-image-2026-03-24-at-00-07-09-7.jpeg) ## 3ème Objectif : Exercice Arduino Initiation à l'électronique et à la programmation Arduino toujours dans le cadre de l'UE "Processus d'Innovation". 👉 **[Voir la documentation complète de l'exercice Arduino](https://wiki.fablab.sorbonne-universite.fr/BookStack/books/projets-due-2025-2026/page/arduino-gaspard-schmitt-raphael-bradshaw)** # Alicia Santi # 1. Impression 3D Pot à Crayon

écrit le 05/01/2026

SANTI Alicia - M1 Management de l’Innovation, Fablab - alicia.santi@etu.sorbonne-universite.fr **Objectifs :** - Concevoir un pot à crayon fonctionnel et esthétique - Découvrir et comprendre le processus de création d’un objet en impression 3D - Apprendre à utiliser un logiciel de modélisation 3D **Contexte :** Dans le cadre de l'UE Processus d'Innovation, nous avons été amenés à concevoir un objet à l’aide de l’impression 3D. J'ai choisi le pot à crayon car il répond à un besoin simple (ranger des stylos, crayons, feutres) tout en ayant un design à faire (forme, taille, écriture "tidy" choisie). L’impression 3D permet de passer rapidement de l’idée à l’objet réel. **Matériaux :** - Filament PLA (acide polylactique) - Couleur : noir - Avantages : facile à imprimer, solide pour un usage quotidien **Machines :** - Imprimante 3D Prusa MK4S - Plateau chauffant - Buse d’extrusion - Cconnexion USB pour transférer le fichier **Outils numériques** - Ordinateur - Logiciel de modélisation 3D OpenScad - Logiciel de tranchage PrusaSlicer **Outils complémentaires** - Spatule pour décoller la pièce du plateau - Cutter ou pince pour retirer les éventuels supports **Construction** $fn = 130; // Paramètres du pot hauteur = 80; rayon\_bas = 25; // diamètre 5 cm rayon\_haut = 30; // diamètre 6 cm epaisseur = 3; // Paramètres du texte message = "tidy"; taille\_texte = 9; profondeur\_texte = 2; union() { // Pot à crayons conique difference() { // extérieur cylinder( h = hauteur, r1 = rayon\_bas, r2 = rayon\_haut ); // intérieur (vide) translate(\[0,0,epaisseur\]) cylinder( h = hauteur, r1 = rayon\_bas - epaisseur, r2 = rayon\_haut - epaisseur ); } // Texte horizontal au-dessus du pot translate(\[0,-29.5,hauteur\]) // juste au-dessus du bord linear\_extrude(height = profondeur\_texte, center = false) text( message, size = taille\_texte, halign = "center", valign = "bottom", font = "Liberation Sans:style=Bold" ); } [![Capture d'écran 2026-01-05 153826.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/capture-decran-2026-01-05-153826.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/capture-decran-2026-01-05-153826.png) ![Une image contenant capture d’écran, texte, Modélisation 3D, conception Le contenu généré par l’IA peut être incorrect.](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/embedded-image-u4oq58ba.jpeg) #### **Étapes du projet** 1. **Recherche et idées** - Observation de pots à crayons existants - Choix du design (forme cylindrique, carrée, originale…) 2. **Modélisation 3D** - Création du modèle sur le logiciel (code ci-dessus) - Définition des dimensions - Vérification de l’épaisseur des parois 3. **Préparation à l’impression** - Export du fichier en format STL binary - Import dans le logiciel de tranchage - Réglage des paramètres d’impression 4. **Impression 3D** - Lancement de l’impression - Surveillance du début de l’impression - Temps d’impression d'environ 1h 5. **Post-impression** - Retrait du pot du plateau - Suppression des supports 6. **Test** - Test avec des crayons **Photos :** [![WhatsApp Image 2026-01-05 at 15.46.09.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/whatsapp-image-2026-01-05-at-15-46-09.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/whatsapp-image-2026-01-05-at-15-46-09.jpeg) Début de l'impression [![WhatsApp Image 2026-01-05 at 15.42.32.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/0eswhatsapp-image-2026-01-05-at-15-42-32.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/0eswhatsapp-image-2026-01-05-at-15-42-32.jpeg) Milieu de l'impression [![WhatsApp Image 2026-01-05 at 16.14.15.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/whatsapp-image-2026-01-05-at-16-14-15.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/whatsapp-image-2026-01-05-at-16-14-15.jpeg)Fin de l'impression Résultat final [![WhatsApp Image 2026-01-05 at 16.13.40.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/whatsapp-image-2026-01-05-at-16-13-40.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/whatsapp-image-2026-01-05-at-16-13-40.jpeg) # 2. Impression 3D dé à 6 faces

écrit le 26/01/2026

**Objectifs :** - Concevoir un dé à 6 faces fonctionnel avec une bille à l'intérieur -> plus de difficulté que le pot à crayon - Approfondir le processus de création d’un objet en impression 3D - Utiliser un logiciel de modélisation 3D **Contexte :** Dans le cadre de l'UE Processus d'Innovation, nous devons concevoir un objet plus "compliqué" à coder et à imprimer. J'ai choisi le dé à faces car tracer les points correspondants aux chiffres des 6 faces a été un vrai défi (bien placer les points sur le dé et équilibre nécessaire). L'objet répond à un besoin simple tout en ayant un design ergonomique. **Matériaux :** - Filament PLA (acide polylactique) - Couleur : Jaune **Machines :** - Imprimante 3D Prusa MK4S - Plateau chauffant - Buse d’extrusion - Connexion USB pour transférer le fichier **Outils numériques** - Ordinateur - Logiciel de modélisation 3D OpenScad - Logiciel de tranchage PrusaSlicer **Outils complémentaires** - Spatule pour décoller la pièce du plateau - Cutter ou pince pour retirer les supports **Construction** [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/FoHimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/FoHimage.png) Le code : $fn=50; difference () { cube (20); translate (\[1,1,1\])cube (18); translate (\[20,10,10\]) sphere (1.5); //face 1 translate (\[0,14,14\]) sphere (1.5); // face 6 translate (\[0,14,10\]) sphere (1.5); translate (\[0,14,6\]) sphere (1.5); translate (\[0,6,14\]) sphere (1.5); translate (\[0,6,10\]) sphere (1.5); translate (\[0,6,6\]) sphere (1.5); translate (\[6,0,6\]) sphere (1.5); //face 2 translate (\[14,0,14\]) sphere (1.5); translate (\[10,20,10\]) sphere (1.5); //face 5 translate (\[14,20,14\]) sphere (1.5); translate (\[6,20,6\]) sphere (1.5); translate (\[14,20,6\]) sphere (1.5); translate (\[6,20,14\]) sphere (1.5); translate (\[6,6,0\]) sphere (1.5); //face 3 translate (\[10,10,0\]) sphere (1.5); translate (\[14,14,0\]) sphere (1.5); translate (\[14,14,20\]) sphere (1.5); //face 4 translate (\[6,6,20\]) sphere (1.5); translate (\[14,6,20\]) sphere (1.5); translate (\[6,14,20\]) sphere (1.5); } translate (\[80,0,3\]) sphere (3); Conception -> calculer le rendu puis Fichier -> exporter -> exporter comme 3MF Prusaslicer : [![Capture d’écran (1).png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/Q5Mcapture-decran-1.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/Q5Mcapture-decran-1.png) Export G-code -> mettre le doc sur la clé pour impression #### **Étapes du projet** 1. **Recherche et idées** - Observation précise d'1 dé à 6 faces 2. **Modélisation 3D** - Création du modèle sur le logiciel (code ci-dessus) - Définition des dimensions 3. **Préparation à l’impression** - Export du fichier en format 3MF - Import dans le logiciel de tranchage - Réglage des paramètres d’impression 4. **Impression 3D** - Lancement de l’impression - Surveillance du début de l’impression - Temps d’impression d'environ 13 min 5. **Post-impression** - Retrait du dé du plateau - Suppression des supports 6. **Test** Pendant l'impression (introduction d'une petite boule dans le dé) : [![IMG_8468.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/img-8468.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/img-8468.jpg) Résultat final [![IMG_8470.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/img-8470.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/img-8470.jpg) # 3. Séance d’électronique voir page wiki : ARDUINO - VARGAS Lilian, SANTI Alicia, Bahar[ https://wiki.fablab.sorbonne-universite.fr/BookStack/books/projets-due-2025-2026/page/arduino-vargas-lilian-santi-alicia-bahar](https://wiki.fablab.sorbonne-universite.fr/BookStack/books/projets-due-2025-2026/page/arduino-vargas-lilian-santi-alicia-jafari-moosavi-bahar) (travail fait en groupe) # PROJET PROTOTYPAGE ARDUINO - Jacques YE, Claire UNG ### **Séance 3 (16/01/2026) - Découverte d'Arduino** > ***Les mots surlignés dans ce document le sont en jaune clair , afin de mettre en évidence uniquement les éléments critiques (sécurité, paramètres importants), sans surcharger la lecture.*** #### INTRODUCTION - ##### **Objectif du projet N°1.1 : LE BLINK - DONNER VIE À LA PREMIÈRE LED ** L'objectif de cette séance est de prendre en main Arduino à travers un premier prototype simple, le programme Blink, qui permet de faire clignoter une LED. Ce premier exercice sert d'introduction à la programmation et à la logique du prototypage rapide. - ##### **Matériel utilisé** - Carte Arduino Uno - planche à pain - Fils de connexion - Câble USB - LED intégrée à la carte (LED sur la broche 13) - 1 résistance - Ordinateur avec Arduino IDE - ##### **Découverte du programme Blink** Le programme *Blink* est un exemple fourni par défaut dans l'IDE Arduino. Il permet de faire clignoter la LED intégrée à la carte à intervalles réguliers. Ce programme introduit : - - La structure du code Arduino ( `setup()`et `loop()`) - La notion de sortie numérique - Les fonctions `digitalWrite()`et`delay()` - ##### **Principe de fonctionnement** - La fonction `setup()`est exécutée une seule fois au démarrage - La fonction `loop()`s'exécute en boucle - La LED s'allume, s'éteint, puis le cycle recommence - ##### **Observations et anecdotes** Lors de l'exécution du programme *Blink* , la LED intégrée à la carte Arduino s'allume et s'éteint de manière régulière. Cette réaction immédiate permet de visualiser concrètement l'effet du code sur un élément physique. Au cours de la séance, certaines difficultés ont été rencontrées, notamment : - - une mauvaise sélection du port de la carte dans l'Arduino IDE - un oubli de téléversement du programme après modification du code Une anecdote marquante de la séance a été le moment où la LED ne clignotait pas. Cette incohérence a d'abord laissé planer le doute, avant de réaliser que la carte n'était pas correctement connectée. Une fois le problème résolu, le clignotement a confirmé le bon fonctionnement du prototype. Cette expérience a été perçue comme une première réussite motivante. - ##### **Résultat** À l'issue de cette séance, le programme *Blink* fonctionne correctement sur la carte Arduino. La LED intégrée clignote selon l'intervalle défini dans le code, validant : - - l'installation de l'environnement de développement - la compréhension de la structure de base d'un programme Arduino - le bon fonctionnement de la carte. Ce premier prototype constitue une base solide pour la suite du travail, notamment l'ajout de composants externes et le développement de projets plus complexes. [![1000850781.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/1000850781.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/1000850781.jpg) **\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_** - ##### **Objectif du projet N°1.2 : JOUER AVEC LA TENSION - DOMPTER LE POULS DU COURANT ** L'objectif de cette seconde étape est de découvrir la lecture d'une entrée analogique avec Arduino à travers le programme *Read Analog Voltage* . Ce projet permet de comprendre comment Arduino peut mesurer une tension variable et afficher des données, ce qui est essentiel dans une démarche de prototypage interactive. - ##### **Matériel utilisé** - Carte Arduino Uno - Câble USB - planche à pain - Potentiomètre - 2 LED - 5 résistances - Fils de connexion - Ordinateur avec Arduino IDE - ##### **Découverte du programme Lire la tension analogique** Le programme *Read Analog Voltage* permet de lire une valeur analogique sur une entrée de la carte Arduino et de l'afficher dans le moniteur série . Ce programme introduit : - - La notion d'entrée analogique - L'utilisation de la fonction`analogRead()` - L'affichage des données via le moniteur série - La conversion d'un signal électrique en valeur numérique - ##### **Principe de fonctionnement** - Le potentiomètre fait varier la tension envoyée à une entrée analogique - Arduino a allumé cette tension grâce à`analogRead()` - La valeur mesurée (entre 0 et 1023) est envoyée au moniteur série - Les valeurs sont mises à jour en continu dans la fonction`loop()` - ##### **Observations et anecdotes** Lors de l'exécution du programme *Read Analog Voltage* , les valeurs affichées dans le moniteur série changent en temps réel lorsque le potentiomètre est tourné. Cela permet de visualiser directement l'impact d'une action physique sur les données numériques. Au cours de la séance, certaines incohérences dans les valeurs affichées ont été enregistrées. Celles-ci étaient dues à un mauvais branchement du potentiomètre sur la breadboard. Après correction des connexions (alimentation, masse et entrée analogique), les valeurs sont devenues cohérentes et stables. Cette étape a permis de prendre conscience de l'importance du câblage et de la précision lors du prototypage électronique. - ##### **Résultat** À l'issue de cette séance, le programme *Read Analog Tension* fonctionne correctement. Arduino a allumé la tension sur l'entrée analogique et affiche les valeurs correspondantes dans le moniteur série, validant : - - la compréhension des entrées analogiques ; - l'utilisation du moniteur série comme outil d'observation ; - la capacité d'Arduino à interagir avec son environnement. Ce deuxième prototype constitue une évolution logique après *Blink* et pose les bases pour l'utilisation de capteurs dans des projets plus complexes. [![img-20260116-160318.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/1Vsimg-20260116-160318.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/1Vsimg-20260116-160318.jpg)
**MESURE DE TENSION****POUR UNE ENTRÉE DE 1V****POUR UNE ENTRÉE DE 3V****POUR UNE ENTRÉE DE 5V**
**OBSERVATION** [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/Ngrimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/Ngrimage.png) [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/Nw1image.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/Nw1image.png) [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/y89image.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/y89image.png)
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ #### APPROFONDISSEMENT DE LA SEANCE - ##### **Objectif du projet N°1.3 : DEUX TEMPOS, UNE SALSA ** L'objectif de cette étape est de contrôler deux LED simultanément avec Arduino, en leur appliquant des fréquences de clignotement différentes. Ce prototype permet d'approfondir la gestion des sorties numériques et la compréhension des temporisations avec la fonction `delay()`. - ##### **Matériel utilisé** - Carte Arduino Uno - Câble USB - 2 LED - 2 résistances - planche à pain - Fils de connexion - Ordinateur avec Arduino IDE - ##### **Principe de fonctionnement** - Les broches 13 et 12 sont configurées comme sorties - La LED sur la broche 13 s'allume et s'éteint avec un délai de 500 ms - La LED sur la broche 12 s'allume et s'éteint avec un délai beaucoup plus court (5 ms) - Les instructions sont exécutées en boucle dans la fonction`loop()` - ##### **Programme Arduino utilisé** ```c void setup() { pinMode(13, OUTPUT); // LED 1 pinMode(12, OUTPUT); // LED 2 } void loop() { digitalWrite(13, HIGH); // LED 13 allumée delay(500); digitalWrite(12, HIGH); // LED 12 allumée delay(5); digitalWrite(13, LOW); // LED 13 éteinte delay(500); digitalWrite(12, LOW); // LED 12 éteinte delay(5); } ``` - ##### **Observations et anecdotes** Lors de l'exécution du programme, on observe que les deux LED ne clignotent pas simultanément. Lorsqu'une LED s'allume, l'autre s'éteint, donnant une impression d'alternance entre les deux LED. La LED connectée à la broche 13 clignote lentement, tandis que celle connectée à la broche 12 s'allume et s'éteint très rapidement. Cependant, en raison de l'utilisation des fonctions `delay()`, le programme s'exécute de manière séquentielle. Cette contrainte empêche les LED de fonctionner de manière totalement indépendante. Cette observation a permis de mieux comprendre le fonctionnement interne de la boucle `loop()`et l'impact des temporisations sur le comportement global du prototype. - ##### **Résultat** À l'issue de cette séance, les deux LED clignotent avec des fréquences différentes conformément au programme écrit. Ce prototype valide : - - l'utilisation de plusieurs sorties numériques ; - la gestion des délais différents dans un même programme ; - la compréhension du fonctionnement séquentiel de la fonction `loop()`. Ce travail constitue une étape supplémentaire dans la maîtrise d'Arduino et prépare à des projets plus complexes impliquant plusieurs actionneurs. \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ - ##### **Objectif du projet N°1.4 : UN BOUTON INTERACTIF - LE POUVOIR AU BOUT DES DOIGTS ** L'objectif de cette étape est d'utiliser un capteur numérique , un bouton poussoir, afin de contrôler l'état d'une LED. Ce prototype permet d'introduire l' interaction utilisateur et de comprendre comment Arduino réagit à une entrée numérique dans une démarche de prototypage. - ##### **Matériel utilisé** - Carte Arduino Uno - Câble USB - DIRIGÉ - Résistance - Bouton poussoir - planche à pain - Fils de connexion - Ordinateur avec Arduino IDE - ##### **Principe de fonctionnement** - Le bouton poussoir est connecté à la broche 4 et configuré comme entrée - La LED est connectée à la broche 12 et configurée comme sortie - Arduino a allumé l'état du bouton à l'aide de la fonction`digitalRead()` - Le bouton est câblé en logique inversée (active LOW) : - bouton relâché → état HIGH - Assistance par bouton → état BAS **Comportement attendu :** - - Lorsque l'utilisateur appuie sur le bouton, la LED s'éteint - Lorsque le bouton est relâché, la LED s'allume - ##### **Programme Arduino utilisé** ```c const int bouton = 4; // la broche 4 devient bouton const int led = 12; // la broche 12 devient led int etatbouton; // variable qui enregistre l'état du bouton void setup() { pinMode(bouton, INPUT); // Initialise le bouton comme entrée pinMode(led, OUTPUT); // Initialise la led comme sortie etatbouton = LOW; // Initialise l'état du bouton Serial.begin(9600); // Ouvre le port série à 9600 bauds } void loop() { etatbouton = digitalRead(bouton); // Lecture de l'état du bouton if(etatbouton == LOW) // bouton appuyé (logique inversée) { digitalWrite(led, LOW); // la LED s'éteint } else // bouton relâché { digitalWrite(led, HIGH); // la LED s'allume } } ``` - ##### **Observations et anecdotes** Lors de l'exécution du programme, observez que la LED est allumée par défaut. Lorsque l'utilisateur appuie sur le bouton poussoir, la LED s'éteint immédiatement. En relâchant le bouton, la LED se rallume. Cette observation peut sembler contre-intuitive au premier abord, mais elle s'explique par le câblage du bouton en logique actif LOW : l'appui sur le bouton correspond à un niveau logique bas (LOW). Cette étape a permis de mieux comprendre le lien entre la connexion physique d'un capteur et le comportement du programme. - ##### **Résultat** À l'issue de cette manipulation, le bouton poussoir permet de contrôler efficacement l'état de la LED. Le prototype répond correctement à la consigne : appuyer sur le bouton provoque l'extinction de la LED . Cette étape valide : - - la lecture d'une entrée numérique - l'utilisation d'un capteur simple - la création d'un prototype interactif Elle constitue une étape clé avant l'utilisation de capteurs plus complexes dans des projets futurs au Fab Lab. # Jafari Moosavi Baharhttps://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/img-8614.jpg #### **M1 Management de l’innovation : 2025-2026** **seyedeh-maryam.jafari-moosavi@etu.sorbonne-universite.fr** ### **Séance 1-2 (16/12/2025 et 09/01/2026): Découverte de l'impression 3D.** #### **Objet réalisé :** Chat qui baille. J'ai obtenu cet objet sur printables.com, un site internet qui permet de recueillir des objets 3D en fichier STL. L'objectif était de découvrir les bases de l'impression 3D en prenant un objet déjà modélisé pour apprendre à utiliser le slicer et les réglages de l'impression 3D. #### **Matériel et logiciel utilisés** - **Imprimante 3D:** Original Prusa MK4S - **Filament**: PLA - **Slicer:** PrusaSlicer **Réglages de l'impression** - **Hauteur de couche:** 0.10mm Fast DETAIL - **Imprimante:** Original Prusa MK4S 0.4 Nozzle - **Filament:** Generic PLA - **Supports:** Partouts - **Remplissage:** 15% - **Température de la buse:** 200 C - **Température du plateau:** 60 C #### Etapes de réalisations 1. Recherche et récupération d’un fichier STL du chat qui baille 2. Importation du fichier STL dans PrusaSlicer - Changements de réglages pour accélérer l'impression et ajouter des supports 3. Génération du G-code pour ensuite le transférer sur clé USB. - Lancement de l’impression 3D après insertion de clé USB - Observation de la formation de la 1ere couche et suivi du déroulement. 4. Détachement de l'objet de la plaque après impression #### Résultat de l'impression: [![Kitty.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/scaled-1680-/kitty.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/kitty.jpg) #### **Conclusion de la séance:** J'ai compris comment imprimer un objet 3D basique a partir d'un fichier STL pour ensuite l'exporter en G-code pour l'imprimante 3D. J'ai appris à paramétrer et à lancer une impression. ### **Séance 3 (16/01/2026): Modélisation d'un objet plus complexe avec une pause pour l'insertion d'une bille** #### **Matériel et logiciel utilisés** - **Imprimante 3D:** Original Prusa MK4S - **Filament**: PLA - **Slicer:** PrusaSlicer **Réglages de l'impression** - **Hauteur de couche:** 0.10mm Fast DETAIL - **Imprimante:** Original Prusa MK4S 0.4 Nozzle - **Filament:** Generic PLA - **Supports:** Uniquement sur la base - **Remplissage:** 15% - **Température de la buse:** 200 C - **Température du plateau:** 60 C L'objectif étaient de imprimer un objet en faisant une pause pour insérer un autre objet. J'ai donc choisi de faire un jouet pour chat. Ci-dessous le code utilisé pour imprimer le jouet pour chat avec des perforations: ``` // ============================================================ // Wiffle Ball — 98 mm diameter, 5 mm wall // 18 holes total: // 1 north pole // 4 upper ring (55° latitude) // 8 equator ring // 4 lower ring (-55° latitude, offset 45°) // 1 south pole // ============================================================ $fn = 80; outer_r = 49; inner_r = 44; hole_r = 8; module punch(dx, dy, dz) { az = atan2(dy, dx); pol = atan2(sqrt(dx*dx + dy*dy), dz); rotate([0, 0, az]) rotate([pol, 0, 0]) translate([0, 0, inner_r - 1]) cylinder(h = 16, r = hole_r); } module ring_holes(lat, n, offset_deg) { phi = 90 - lat; for (i = [0 : n-1]) { a = 360 * i / n + offset_deg; dx = sin(phi) * cos(a); dy = sin(phi) * sin(a); dz = cos(phi); punch(dx, dy, dz); } } difference() { sphere(r = outer_r); sphere(r = inner_r); // North pole punch(0, 0, 1); // Upper ring: 4 holes at +55° ring_holes(55, 4, 0); // Equator: 8 holes ring_holes(0, 8, 0); // Lower ring: 4 holes at -55°, offset 45° ring_holes(-55, 4, 45); // South pole punch(0, 0, -1); } ``` J'ai donc fais une bille en parallel, et voici le code: ``` $fn = 80; balle_r = 43; // inner_r du wiffle ball = 44, donc 1mm de jeu sphere(r = balle_r); ``` [![IMG_8608.jpg.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/scaled-1680-/img-8608-jpg.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/img-8608-jpg.jpg) J'ai effectué tuer une pause dans la première impression pour pouvoir insérer la bille: [![IMG_8611.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/scaled-1680-/img-8611.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/img-8611.jpg)![IMG_8614.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/scaled-1680-/img-8614.jpg) Ensuite j'ai relancé l'impression afin d'avoir l'objet final avec la bille à l'intérieur: [![IMG_8618.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/scaled-1680-/img-8618.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-04/img-8618.jpg) L'objectif est réussi, j'ai ensuite utilisé du papier sablé pour lisser la surface du cote de la ou était le support. # Kristina, Bence & Demir - Partie Arduino ## **Arduino partie 1** #### **Objectif :** Illuminer la première LED (Blink) #### **Matériel Utilisé** - Ordinateur avec Arduino IDE - Carte Arduino Uno - Planche à pain (Breadboard) - Câble USB - x1 LED (intégrée ou externe) - x1 Résistance - Fils de connexion #### **Programme Arduino** ``` void setup() { // Initialise la broche 13 comme une sortie pinMode(13, OUTPUT); } void loop() { digitalWrite(13, HIGH); // Allume la LED delay(1000); // Attend 1 seconde digitalWrite(13, LOW); // Éteint la LED delay(1000); // Attend 1 seconde } ``` #### **Principe** - La LED sur la broche 13 s'allume et s'éteint avec un délai de 1000ms (1 seconde). - La fonction `setup()` initialise la configuration une seule fois au démarrage. - Les instructions sont répétées à l'infini grâce à la fonction `loop()`. - La broche 13 est configurée comme une sortie numérique. #### **Observation** La LED clignote de manière régulière, validant ainsi la communication entre l'ordinateur et la carte. #### **Visuels** **[![photo_2026-02-08_15-29-00.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/photo-2026-02-08-15-29-00.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/photo-2026-02-08-15-29-00.jpg)** --- ## **Arduino partie 2** #### **Objectif:** Dompter le pouls du courant (Lecture analogique et contrôle de LED) #### **Matériel Utilisé** - Ordinateur avec Arduino IDE - Carte Arduino Uno - Planche à pain (Breadboard) - Câble USB - x1 Potentiomètre (pour varier la tension) - x2 LED (sur les broches 13 et 12 selon votre montage) - x5 Résistances - Fils de connexion (reliés aux broches : GND, 13, 12, 11, A0, 5V) #### **Programme Arduino** ``` void setup() { Serial.begin(9600); pinMode(13, OUTPUT); pinMode(12, OUTPUT); pinMode(11, OUTPUT); } void loop() { int sensorValue = analogRead(A0); // Convertit la lecture en tension (0 - 5V) float voltage = sensorValue * (5.0 / 1023.0); // Affiche la tension dans le moniteur série Serial.print("Tension mesuree : "); Serial.print(voltage); Serial.println(" V"); // Interaction simple : si la tension dépasse 2.5V, on allume les LED if (voltage > 2.5) { digitalWrite(13, HIGH); digitalWrite(12, HIGH); } else { digitalWrite(13, LOW); digitalWrite(12, LOW); } delay(100); // Petit délai pour la stabilité de l'affichage } ``` #### **Principe** - Le potentiomètre fait varier la tension envoyée à l'entrée A0. - La fonction `analogRead(A0)` convertit ce signal électrique en une valeur numérique entre 0 et 1023. - Les données sont envoyées en continu vers l'ordinateur pour être visualisées via le moniteur série. - Les broches 13, 12 et 11 sont utilisées comme sorties pour réagir en fonction de la tension lue. #### **Observation** Les valeurs dans le moniteur série changent en temps réel lorsque l'on tourne le potentiomètre. #### **Visuels** **[![photo_2026-02-08_15-12-55.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/photo-2026-02-08-15-12-55.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/photo-2026-02-08-15-12-55.jpg)** --- ## **Arduino partie 3** #### **Objectif:** Clignoter deux LED á deux fréquences différentes. #### **Matériel Utilisé** - Ordinateur avec Arduino IDE - Carte Arduino Uno - planche à pain - Câble USB - x2 LED - x2 résistances - Fils de connexion #### **Programme Arduino** ``` void setup() { pinMode(13, OUTPUT); pinMode(12, OUTPUT); } void loop() { digitalWrite(13, HIGH); delay(600); digitalWrite(12, HIGH); delay(20); digitalWrite(13, LOW); delay(600); digitalWrite(12, LOW); delay(20); } ``` #### **Principe** - LED broche 13 s'allume et s'éteint avec un délais de 600ms. - LED broche 12 s'allume et s'éteint avec un délais de 20ms. - Les instructions sont loupées grace au fonction `loop()` - Les broches 13 et 12 sont des sorties #### **Observation** Les deux LEDs clignotent avec des vitesses différentes. Le LED 1 est plus rapide que le LED 2. --- ## **Arduino partie 4** #### **Objectif:** Allumer deux LED avec un actionneur (par ex un bouton) selon les conditions de l'actionneur. #### **Matériel Utilisé** - Ordinateur avec Arduino IDE - Carte Arduino Uno - planche à pain - Câble USB - x2 LED - x2 résistances - Fils de connexion - Bouton #### **Fonctionnement** **Configuration des E/S:** Le dispositif utilise la broche 4 comme entrée numérique (bouton) et la broche 12 comme sortie (LED). **Méthode de Lecture:** Le microcontrôleur interroge l'état de l'entrée via la fonction digitalRead(). **Logique de Commande:** Le circuit est câblé en logique négative (Active LOW). Par conséquent, l'entrée est à l'état HIGH au repos et bascule à l'état LOW lors d'une pression. **Logique de Sortie:** Le système suit une relation inverse : la LED s'éteint lors de l'activation du bouton et s'active lorsque celui-ci est relâché. #### **Programme Arduino** ``` /** * Gestion d'une LED en logique inversée via bouton-poussoir * Broche 4 : Entrée Bouton (Active LOW) * Broche 12 : Sortie LED */ // Définition des constantes pour une meilleure lisibilité const int PIN_INPUT = 4; const int PIN_OUTPUT = 12; void setup() { // Configuration des entrées/sorties pinMode(PIN_INPUT, INPUT); pinMode(PIN_OUTPUT, OUTPUT); // Initialisation de la console pour le débogage Serial.begin(9600); } void loop() { // Lecture de l'état actuel du capteur int signalAction = digitalRead(PIN_INPUT); // Traitement de la logique : La LED suit l'état du bouton // (Bouton LOW -> LED LOW | Bouton HIGH -> LED HIGH) if (signalAction == LOW) { digitalWrite(PIN_OUTPUT, LOW); // Extinction lors de l'appui } else { digitalWrite(PIN_OUTPUT, HIGH); // Allumage au repos } } ``` #### **Observation** Si on appuie sur le bouton, la LED s'éteint. # Projet Arduino - Angel CHEN et Mariia KARPENKO ##### **Activité 1 - Clignotement Asymétrique** L'objectif de cette activité est de prendre en main Arduino à travers un prototype simple, le montage et la programmation d'un clignotement asymétrique de plusieurs LED. ##### **Matériel utilisé** - - Carte Arduino Uno - Breadboard - 5 Fils de connexion - 1 câble USB - 3 LED de couleurs différentes - 3 résistance - Ordinateur avec Arduino IDE ##### **Objectifs** - Réaliser un montage Arduino permettant de faire clignoter trois LED de manière indépendante. - Implémenter des fréquences distinctes : - LED 1 : toutes les 2 secondes - LED 2 : toutes les 100 millisecondes - LED 3 : toutes les 500 millisecondes - Vérifier le comportement du circuit par simulation avant la mise en œuvre réelle. ##### **Principe de fonctionnement** - - La fonction `setup()`est exécutée une seule fois au démarrage - La fonction `loop()`s'exécute en boucle - La LED s'allume, s'éteint, puis le cycle recommence ##### **Le Code** ``` //Voici notre code void setup() { pinMode(LED_BUILTIN, OUTPUT); // LED 1 pinMode(12, OUTPUT); // LED 2 pinMode(8, OUTPUT); // LED 3 } void loop() { // LED 1 clignote lentement (2 s ON / 2 s OFF) digitalWrite(LED_BUILTIN, HIGH); delay(2000); digitalWrite(LED_BUILTIN, LOW); delay(2000); // LED 2 clignote plus vite (100 ms ON / 100 ms OFF) digitalWrite(12, HIGH); delay(100); digitalWrite(12, LOW); delay(100); // LED 3 clignote plus vite (500 ms ON / 500 ms OFF) digitalWrite(8, HIGH); delay(500); digitalWrite(8, LOW); delay(500); } ``` ##### **Le résultat** Visible ici : [Activité 1.mp4](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1654) [![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/kaVimage.png) ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/kaVimage.png)[![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/1j7image.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/1j7image.png) \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ ##### **Activité 2 - Utilisation d'un capteur pour réaliser un montage** L'objectif de cette activité est de complexifier le programme en ajoutant l'action d'un capteur de notre choix. ##### **Matériel utilisé** - - Carte Arduino Uno - Breadboard - 7 Fils de connexion - 1 Câble USB - 2 LED de couleurs différentes - 2 Résistance - 1 Capteur de proximité - Ordinateur avec Arduino IDE ``` void setup() { Serial.begin(9600); pinMode(2, INPUT); // capteur de proximité pinMode(12, OUTPUT); // LED : somebody here pinMode(13, OUTPUT); // LED : nobody } void loop() { delay(500); if (digitalRead(2) == LOW) { Serial.println("Somebody is here."); digitalWrite(12, HIGH); // LED présence ON digitalWrite(13, LOW); // LED absence OFF } else { Serial.println("Nobody."); digitalWrite(12, LOW); // LED présence OFF digitalWrite(13, HIGH); // LED absence ON } } ``` Tableau de bord Nous avons essayé avec un capteur de son, mais le micro ne fonctionnais pas donc nous avons bifurqué vers le capteur de proximité. Le montage n'est pas propre car nous découvrons l'électronique, mais au moins le code fonctionne ! ##### **Le résultat** [![20260209_171702.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/20260209-171702.jpg) ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/20260209-171702.jpg)[![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/PBIimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/PBIimage.png) Les images faites sur TinkerCad ont été faites plusieurs jours après les montages car nous pensions qu'il manquait de visibilité à nos images. Mais nous ne garantissons pas que la modélisation est fidèle à notre image d'origine car les possibilités de TinkerCad sont limitées. # Laura Martínez. #### **Coordonnées :** - **Adresse mail :** laura.martinez\_castro@etu.sorbonne-universite.fr - **Cursus :** Master 1 Management de l’innovation ##### **Introduction** - **Date de début :** 14/01/2026 - **Date de fin estimée :** 14/01/2026 - **Objectifs :** Découvrir le logiciel PrusaSlicer. #### **Matériaux / Outils / Machines** - **Logiciels :** PrusaSlicer - **Plateforme :** Printables (le modèle 3D) - **Matériau prévu :** PLA (Diamètre 1,75 mm) - **Outils de finition :** Spatule (pour le décollage) ### **Première séance – Initiation à l’impression 3D avec PrusaSlicer** **vendredi 16 Janvier 2026** Lors de cette première séance au FABLAB, l’objectif principal était de se familiariser avec les bases de l’impression 3D ainsi qu’avec les outils nécessaires à la préparation d’un modèle avant fabrication. Cette session a permis de découvrir le fonctionnement général des imprimantes 3D Prusa MK4S ainsi que l’utilisation du logiciel de tranchage PrusaSlicer. L’activité consistait à comprendre les différentes étapes nécessaires pour passer d’un modèle numérique à un objet physique imprimé en 3D. ### **Choix et importation du modèle** Pour cette première expérience, j’ai sélectionné un modèle disponible sur la plateforme Printables, directement accessible depuis PrusaSlicer. Le fichier au format STL a ensuite été importé dans le logiciel afin de préparer l’impression. Le modèle choisi correspond à un petit objet décoratif de type porte-bougie (tealight holder) présentant une structure organique composée de formes allongées. ### **Préparation du fichier dans PrusaSlicer** Après l’importation du modèle, plusieurs paramètres d’impression ont été ajustés afin d’optimiser la fabrication : - sélection du filament **PLA générique**, - configuration de l’imprimante **Original Prusa MK4S (buse 0,4 mm)**, - activation des supports d’impression, - réglage du taux de remplissage à **15 %**, - adaptation de la taille et de la position de l’objet sur le plateau. Une fois les paramètres validés, le logiciel a généré le **G-code**, fichier contenant les instructions nécessaires au déplacement de la tête d’impression couche par couche. *[![37e35b43-a07a-48a8-9880-2c610be76be3.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/37e35b43-a07a-48a8-9880-2c610be76be3.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/37e35b43-a07a-48a8-9880-2c610be76be3.jpg)* ### **Visualisation avant impression** Avant le lancement de l’impression, une simulation a été réalisée dans PrusaSlicer afin d’observer : - la décomposition du modèle en couches successives, - le temps d’impression estimé, - la quantité de filament utilisée, - les zones nécessitant des supports. Cette étape permet d’anticiper d’éventuels défauts et de vérifier la faisabilité de l’impression. ### **Résultat de l’impression** L’objet imprimé présente une structure complexe composée de multiples éléments inclinés, démontrant les capacités de fabrication additive pour des géométries difficiles à produire par des méthodes traditionnelles. *[![f72124f4-e2b8-477f-adc6-9cd630b2a64d.jpg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/f72124f4-e2b8-477f-adc6-9cd630b2a64d.jpg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/f72124f4-e2b8-477f-adc6-9cd630b2a64d.jpg)* ### **Analyse post-impression** Après l’impression, plusieurs observations ont été réalisées : - Le retrait des supports s’est révélé délicat, notamment au niveau de la base, où leur adhérence était importante. Cela a compliqué le post-traitement sans altérer la surface. - Certaines zones en surplomb présentent un léger affaissement du matériau, dû au refroidissement du filament dans le vide avant solidification complète. - On observe également de fines stries visibles correspondant aux couches d’impression, ainsi que de légères irrégularités liées aux mouvements rapides de la tête d’impression. Ces éléments illustrent l’influence directe des paramètres d’impression sur la qualité finale de la pièce. ### **Deuxième séance – Conception et fabrication d’un objet fonctionnel en impression 3D** ### **Contexte** Dans le cadre de l’UE *Processus d’Innovation*, cette deuxième séance avait pour objectif de concevoir un objet personnalisé intégrant une fonction réelle, depuis la modélisation numérique jusqu’à la fabrication finale par impression 3D. Contrairement à la première séance basée sur l’impression d’un modèle existant, cette activité reposait sur une démarche complète de conception, incluant la modélisation, la métrologie, l’ajustement des paramètres d’impression et l’intégration d’un composant physique. ### **Objectifs** - Concevoir un **magnet en forme de cœur** - Approfondir la compréhension du processus d’impression 3D - Intégrer un élément fonctionnel (aimant) directement dans la pièce imprimée ### **Métrologie et ajustement dimensionnel** Avant la modélisation finale, l’aimant a été mesuré afin de garantir son insertion correcte dans la pièce. *[![IMG_8329.JPG](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/img-8329.JPG)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/img-8329.JPG)* À l’aide d’un pied à coulisse numérique, les dimensions suivantes ont été relevées : - diamètre ≈ **9,90 mm** - épaisseur mesurée avec précision millimétrique. Afin d’assurer un bon assemblage, une tolérance dimensionnelle a été appliquée lors de la conception. Le logement de l’aimant a été modélisé légèrement plus grand (≈ +0,1 à 0,2 mm). Cette marge est nécessaire car, lors de l’impression 3D FDM : - le filament fondu peut légèrement s’étaler, - le matériau se contracte en refroidissant, - les dimensions réelles diffèrent légèrement du modèle numérique. Sans cette tolérance, l’aimant n’aurait pas pu être inséré correctement. ### **Préparation à l’impression (Slicing)** Après la modélisation, le fichier a été exporté en format STL puis importé dans PrusaSlicer. Les paramètres principaux ont été ajustés afin d’assurer la solidité de la pièce : - choix du filament PLA, - réglage du remplissage (infill), - adaptation de la hauteur de couche, - positionnement optimal sur le plateau. Une simulation couche par couche a permis de visualiser le déroulement de l’impression et d’estimer le temps nécessaire. ### **Insertion de l’aimant – Pause programmée** Pour intégrer l’aimant directement à l’intérieur de la pièce, une fonction avancée du slicer a été utilisée. Grâce au visualiseur de couches : 1. la hauteur correspondant à la fermeture du logement de l’aimant a été identifiée ; 2. une pause automatique a été programmée à cette couche précise. Pendant l’impression : - l’imprimante s’est arrêtée automatiquement, - la buse s’est déplacée hors de la zone d’impression, - l’aimant a été placé manuellement dans son logement. L’impression a ensuite repris, recouvrant l’aimant par les couches supérieures, le rendant invisible et parfaitement intégré à l’objet. ## **Résultat final** Le cœur imprimé présente : - une bonne résistance mécanique, - un aimant totalement intégré, - une surface propre et homogène. L’aimantation fonctionne correctement à travers la fine couche de plastique supérieure, validant pleinement la fonctionnalité de l’objet. [![IMG_8526.JPG](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/img-8526.JPG)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/img-8526.JPG) ## **Conclusion** Cette séance a permis de comprendre que la conception d’un objet fonctionnel en impression 3D nécessite une approche itérative combinant : - modélisation numérique, - mesures réelles, - gestion des tolérances, - optimisation des paramètres d’impression. L’expérience a mis en évidence l’importance du lien entre conception théorique et contraintes physiques de fabrication additive.