# MU4MN011 - Processus d'innovation
Introduction au prototypage rapide au FabLab.
CAO et impression 3D. OpenSCAD et Arduino.
# New Page
# New Page
# New Page
# New Page
# Descriptif de l'UE
Introduction au prototypage rapide.
1ère partie : conception et fabrication additive (impression 3D).
2ème partie : introduction à Arduino et objets interactifs.
# New Page
# New Page
# New Page
# Première séance : introduction OpenSCAD
Découverte d'OpenSCAD, commandes simples, boucles et union et différence.
# Sarah DELAPILLE
**18/10/23 :** Cours
- Découverte d'OpenSCAD et d'IdeaMaker
- Opérations simples sur OpenSCAD
**27/10/23:**
- Devoirs : Imprimer en 3D un objet original conçu avec OpenSCAD + un objet qui soit impossible à construire sans l’impression 3D.
Objet : Fourchette 1er jet : possibilité d'améliorer l'objet et de faire un code plus simple.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/p0pimage.png)
**24/10/23 : **Impression 3D de la fourchette
- Fourchette est très petite. Un des piques est déformé. Problème dû au fait que ça soit trop petit ?
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/fourchette-1.jpg)
\---------------------------------------------------------------------------------------------------------------------------------------------
Objet qui soit impossible à construire sans impression 3D : un globe dans un rectangle.
**27/10/2023 :** Cours
- Insérer un autre objet dans l'objet que nous voulons imprimer en 3D. Le faire en faisant un réglage sur IdeaMaker pour qu'il pause l'impression et qu'on puisse insérer l'objet. Attention à ne pas faire en sorte que l'objet insérer soit plus grand que la dernière couche de l'objet imprimé en 3D. Essayant de travailler en plusieurs plusieurs couleurs (réglage dans IdeaMaker)
- Post traitement :
- Prendre un becher, mettre l'objet et du sable tout autour. Mettre le tout dans un four et monter à 115 degrés pour durcir, renforcer la cohésion.
- Prendre un bécher, mettre un solvant selon le polymère utilisé, on chauffe le temps que le solvant s'évapore et l'objet deviendra brillant et lissant.
**14/11/2023 :**
Objet en collaboration avec Alix DELOBELLE : le Ying et le Yang aimanté
```c++
$fn=100;
wall=3; walls=wall*2;
Height=10;
Diameter=100;
Ying();
module Ying() {
difference(){
translate([Diameter/4 ,0,0])color("black",1)
cylinder(h=Height,d=Diameter/2,$fn=100,center=true); //top Circle
color("white",1){
translate([Diameter/4,0,1])
cylinder(10,d=Diameter/4-walls,$fn=100,center=true);}
color("blue",1) translate([4.2, 3, 0]) cube(6,6,4, center=true,$fn=100);}
difference()
{color("black",1)cylinder(h=Height,d=Diameter,$fn=100,center=true);
translate([0,Diameter/2,0])
cube([Diameter,Diameter,Height+4],$fn=100,center=true);
color("white",1){
translate([Diameter/4,0,1])
cylinder(h=Height,d=Diameter/4-walls,$fn=100,center=true);}
translate([-Diameter/4 ,0,0])
cylinder(h=Height+4,d=Diameter/2 ,$fn=100, center=true); } }
```
Le cube dans le programme a pour fonction d'insérer l'aimant. Sur ideaMaker, nous avons créer un modificateur aux dimensions du trou av=fin de permettre la bicolore. Il faut utiliser deux extruders pour les deux couleurs et avant d'étiter le slide, il faut programmer un arret à 7mm pour introduire l'aimant.
Première impression : Echec car l'extruder droit ne fonctionnait pas
Deuxième impression : Impression sur une autre machine
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/qcAimage.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/rGoimage.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/cf2f64a7-6900-4249-8258-e9c95ea5d493.jpg)
# Jade Mahé
**18/10/23 :** Cours
- Découverte d'OpenSCAD et d'IdeaMaker
- Opérations simples sur OpenSCAD
**24/10/23:** Impression 3D Fablab
Devoirs pour le 27/10/23 :
- Imprimer en 3D un objet avec union et différence
- Imprimer en 3D un objet qui soit impossible à construire sans l’impression 3D.
1. Sphère avec bille : **voir code aux bonnes dimensions plus bas.**
2. Vide poche : **voir code aux bonnes dimensions plus bas.**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/CUVimage.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/Ysm3rvimage.png)
Problèmes rencontrés : Impression au mm au lieu de cm. (Je n'avais pas fait attention que l'on était sur une échelle en mm et non cm sur OpenSCAD.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/8Ymimage.png)
**25/10/23:**
\--> Remise des maquettes en cm sur OpenSCAD.
**Codes OpenSCAD : **
*Sphère avec bille :*
```python
difference(){
color("pink")sphere(r=20, $fn=100);
color("pink") sphere(r=15.7,$fn=100);
color("pink") cylinder(h=70,r=10.7, center=true, $fn=100);
color("pink") rotate ([90,0,0]) cylinder(h=70,r=10.7, center=true, $fn=100);
color("pink") rotate ([0,90,0]) cylinder(h=70,r=10.7, center=true, $fn=100);
}
color("white") sphere(r=11.8,$fn=100);
```
Lien Fichier OpenSCAD : [sphere in sphere PLUS.scad](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/439)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/qxWimage.png)
*Vide poche :*
```python
union(){
difference(){
color("black") cube (size=[70,70,20], center=true);
color("gold") translate([0,0,-0.7])cylinder(h=20,r=33.5,$fn=100);
}
color("gold") translate ([30,30,-14])sphere(r=6,$fn=100);
color("gold") translate ([-30,-30,-14])sphere(r=6,$fn=100);
color("gold") translate ([-30,30,-14])sphere(r=6,$fn=100);
color("gold") translate ([30,-30,-14])sphere(r=6,$fn=100);
}
```
Lien Fichier OpenSCAD : [porte bijoux.scad](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/440)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/royimage.png)
**Réglages IdeaMaker 1 : **
- Ajout de support de façon manuelle
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/mFFimage.png)
**Résultats d'impressions : **
Problèmes rencontrés : Manque d'adhésion, décrochage lors de l'impression :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/mXXimage.png)
**Réglages IdeaMaker 2 : **
- Mise en place de supports
- Mise en place de supports d'adhérence types radeaux (notamment pour essayer d'éviter le décrochage de la sphère)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/WUfimage.png)
**Résultats d'impressions : **
--> Utilisation de PLA blanc
- Impression vide poches : Réussite
- Impression sphère : Problème d'adhérence, de support il faudrait peut-être utiliser une jupe ou bien modifier le support et densité.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/25eimage.png)
[**27/10/2023 : Cours** ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/download.png)
- Présentation des diverses méthodes d'utilisation de l'imprimante 3D
- Devoir pour le 16/11 : réaliser un objet en bi-colore dans lequel on peut insérer un autre objet en arrêtant l'impression
**Codes OpenSCAD : **
```python
union(){
difference(){
cylinder(6,13,13, $fn=100);
translate([0,0,2])cylinder(6,10.2,10.2, $fn=100);
}
translate([0,0,6.5])cube([26,2,2], center=true);
translate([0,0,6.5])rotate (90,0,0) cube([26,2,2], center=true);
}
```
Lien Fichier OpenSCAD : [Porte pièce.scad](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/438)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/aMfimage.png)
**Réglages IdeaMaker : **
- Mise en place d'un modificateur (cylindre) au niveau de la base + réglage des extrudeurs gauche et droit afin d'obtenir un objet bi-colore.
- Réglage d'un temps d'arrêt à 5mm afin de pouvoir intégrer une pièce à l'intérieur de l'objet. (Pour cela aller dans slice > Editer > Autre > Régler la pause )
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/rSsimage.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/cP4image.png)
**Résultats d'impressions : 14/11/23**
--> Utilisation de PLA orange et marbré
- Impression : réussite et pause effectué automatiquement pour insérer la pièce
- Petit manque de précision
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/ucNimage.png)
# Alix Delobelle
**18/10/2023 : Cours de prototypage**
- Première approche du logiciel Openscad pour créer des objets en 3D
- Compréhension du langage
- Matérialisation de l'objet sur Ideamaker afin de pouvoir l'imprimer
**25/10/2023 : Création et impression de deux objets**
*1- Objet 1 : créer un objets utilisant différence et addition*
- Réalisation de deux briques type Légo, un rectangle et un carré
- Cependant, erreur dans le codage sur openscad car la face du dessous n'a pas été enlevée correctement, ce qui ne permet pas d'emboiter les deux briques
- Changement à réaliser dans le programme avec réalisation d'une différence pour enlever la face du dessous
- **[Programme réalisé sur OPENSCAD :](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/LJgimage.png)**
- *$fn=100;*
*difference(){*
*color ("white")cube(\[32,16,9\]);*
*translate(\[0,0,-9\]) color ("white") cube(\[32,16,9\]);*
*};*
*translate(\[3.5,3.5,8.5\]) color("pink") cylinder(2,2.5,2.5) ;*
*translate (\[3.5,12.5,8.5\]) color("green")cylinder(2,2.5,2.5);*
*translate (\[11.8,3.5,8.5\]) color("black")cylinder(2,2.5,2.5);*
*translate (\[11.8,12.5,8.5\]) color("red")cylinder(2,2.5,2.5);*
*translate (\[20.1,3.5,8.5\]) color("blue")cylinder(2,2.5,2.5);*
*translate (\[20.1,12.5,8.5\]) color("purple") cylinder(2,2.5,2.5);*
*translate (\[28.4,3.5,8.5\]) color("orange") cylinder(2,2.5,2.5);*
*translate (\[28.4,12.5,8.5\]) color("brown") cylinder(2,2.5,2.5);*
*translate (\[8,8,0\]) difference (){*
*cylinder(8,3.5,3.5);*
*cylinder (8,2.5,2.5);*
*}*
*translate (\[16,8,0\]) difference (){*
*cylinder(8,3.5,3.5);*
*cylinder (8,2.5,2.5);*
*}*
*translate (\[24,8,0\]) difference (){*
*cylinder(8,3.5,3.5);*
*cylinder (8,2.5,2.5);*
*}*
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/Fviembedded-image-eyc0uj91.png)
*2- Objet 2 : créer un objet que l'on peut imprimer qu'en 3D*
- Réalisation d'une tirelire à destination d'un test de dextérité manuelle en psychomotricité
- Programme réalisé sur openscad mais échec lors de l'impression --> non réalisation de l'épaisseur des murs ce qui a conduit à une mauvaise impression de la la boite (en 2D et non 3D)
- [Reprise du programme sur openscad et ajustement de l'épaisseur des murs ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/io9embedded-image-4fvemhsh.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/download.png)
[**27/10/2023 : Cours de prototypage** ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/download.png)
- Présentation des réalisations à la classe
- Présentation du fonctionnement de l'imprimante 3D et des différents fil que l'on peut utiliser
- Consigne : réaliser un objet en bi-colore dans lequel on peut insérer un autre objet en arrêtant l'impression 3
Réalisation d'un yin-yang aimanté avec Sarah DELAPILLE
*$fn=100;*
*wall=3; walls=wall\*2;*
*Height=10;*
*Diameter=100;*
*Ying();
*module Ying() {*
*difference(){*
*translate(\[Diameter/4 ,0,0\])color("black",1)*
*cylinder(h=Height,d=Diameter/2,$fn=100,center=true); //top Circle*
*color("white",1){*
*translate(\[Diameter/4,0,1\])*
*cylinder(10,d=Diameter/4-walls,$fn=100,center=true);}*
*color("blue",1) translate(\[4.2, 3, 0\]) cube(6,6,4, center=true,$fn=100);}*
*difference()*
*{color("black",1)cylinder(h=Height,d=Diameter,$fn=100,center=true);*
*translate(\[0,Diameter/2,0\])*
*cube(\[Diameter,Diameter,Height+4\],$fn=100,center=true);*
*color("white",1){*
*translate(\[Diameter/4,0,1\])*
*cylinder(h=Height,d=Diameter/4-walls,$fn=100,center=true);}*
*translate(\[-Diameter/4 ,0,0\])*
*cylinder(h=Height+4,d=Diameter/2 ,$fn=100, center=true); } }*
Création sur open-scad
- Modèle Ying Yang double couleur avec introduction à l'intérieur d'un cube
- Les deux modèles sont identiques
- Le cube a pour fonction d'y placer l'aimant afin de pouvoir relier les deux parties. Il est plus grand que l'aimant afin que l'on puisse stopper l'impression et le placer sans que la structure ne s'effondre
Sur ideamaker :
- Création d'un modificateur aux dimension du trou afin de permettre la bicolore (procédure : onglet modifier, ajouter un modificateur, donner les dimensions et le placer au bon endroit) [](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/a3Mimage.png)
- Utilisation des deux extruders pour les deux couleurs : sur le menu de gauche (les trois traits horizontaux) --> cocher trancher les modèles actifs uniquement, puis sélectionner que le yang, aller dans la clé à molette sur le côté et sélectionner extruder de gauche. Puis, désélectionner le yang et sélectionner le cylinder, aller dans la molette et mettre extruder de droite) [](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/rmmqtximage.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/WZ8image.png)
- Avant d'éditer le slide, réalisation d'un arrêt de l'impression à 7 mm, afin de pouvoir y introduire l'aimant (procédure : slice, démarrer le slice, éditer, autre, hauteur (sélectionner la bonne)) [](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/jraimage.png)
**14/11/2023 :**
- Tentative d'impression mais échec car l'extruder de droite ne fonctionnait pas
- Arrêt de l'impression, tentative sur une autre machine
- Erreur dans la programmation du rond central car la couleur noir est restée accrochée sur la radeau
- Changement dans le code open-scad à revoir
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/rGoimage.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/cf2f64a7-6900-4249-8258-e9c95ea5d493.jpg)
# Chloé El Kassis
18/10/2023
Découverte des logiciels OpenScad et IdeaMaker
Code:
```
d=5;
a=10;
H=100;
R=40;
N=10;
color("red") cube(a,center=true);
union(){
for (i=[1:1:N){
rotate([0,0,i*360/N)translate([R-1/2),0,H+a/2])
cube(a,center=true);
}
color("red")cylinder(h=H,r=R);
}
```
26/10/2023
Perle en Forme de cœur
```
difference(){
color("gold") union(){
$fn=100;
cube(20);
translate([10,0,0])
union(){
cylinder(h=20,d=20);
translate([-10,10,0])cylinder(h=20,d=20);}
}
rotate([45,90,0])translate([-10,4,-20]) cylinder(h=40,r=2,center = false,$fn=100);
}
```
Lors de la première impression, le petit bou de plastique est resté accroché.
Qualité standard
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/whatsapp-image-2023-11-13-at-09-12-14.jpeg)
La deuxième impression s’est bien déroulée. La perle était cependant trop grande pou une perle.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/whatsapp-image-2023-11-13-at-09-12-14-1.jpeg)
Porte-Bouquet
```
difference(){
union(){
translate([0,0,-6])
linear_extrude(1,center=true,scale=1)
circle(d=62);
rotate_extrude($fn=300)
translate([30,0,0])
scale([0.5,1.5])
circle(d=10,$fn=100);
}
translate([0,0,-10]) cylinder(h=20,r=2,$fn=100) ;
N=10;
F=20;
union(){
for(i=[1:1:N]){
rotate([0,0,i*360/N])translate([10,0,-10])
cylinder(h=20,r=2,$fn=100);
}
union(){
for(i=[1:1:F]){
rotate([0,0,i*360/F])translate([20,0,-10])
cylinder(h=20,r=2,$fn=100);
}
}
}
}
```
Les trous ne sont pas assez larges pour mettre des tiges à l’intérieur, ils ne sont également pas bien délimités.
(Insérez photo)
11/13/2023
L'exercice consistait à créer un objet et de mettre quelque chose à l'intérieur. J'ai décidé de faire une maracas en mettant des pates dedans (pates alphabet) selon le code suivant:
J'ai utilisé une bobine de PLA de couleur violet. J'avais réglé sur IdeaMaker d'utiliser l'extruder de droite. En emprimant une première fois, l'extruder n'a pas rempli le centre du cylindre et donc j'ai arrêté l'impression.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/whatsapp-image-2023-11-16-at-08-45-53-20599f41.jpg)
Pour la deuxième impression j'ai diminué la taille de l'impression. J'ai vite remarqué que le remplissage se faisant avec l'extruder de gauche. Vu que la taille de la maracas était réduit, cela n'était pas une bonne idée. Il y avait des fils de partout. Après avoir retiré l'objet, et l'avoir déposé sur la table, celui la s'est cassé.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/whatsapp-image-2023-11-16-at-08-45-54-7cf3bb22.jpg)
*12/08/2023*
Avec le kit arduino, le premier objectif était de faire clignotté deux LED de facon alternée.
```
void setup() {
pinMode(9,OUTPUT);
pinMode(13,OUTPUT);
}
void loop() {
digitalWrite(9,HIGH);
digitalWrite(13,LOW);
delay(1000);
digitalWrite(9,LOW);
digitalWrite(13,HIGH);
delay(1000);
}
```
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-12/whatsapp-image-2023-12-08-at-13-44-52.jpeg)
Ensuite, l'objectif était d'aleterner 3 LED:
```
void setup(){
pinMode(9,OUTPUT);
pinMode(13,OUTPUT);
pinMode(11,OUTPUT);
}
void loop() {
digitalWrite(9,HIGH);
digitalWrite(13,LOW);
delay(1000);
digitalWrite(11,HIGH);
delay(500);
digitalWrite(9,LOW);
digitalWrite(13,HIGH);
delay(1000);
digitalWrite(11,LOW);
delay(500);
}
```
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-12/whatsapp-image-2023-12-08-at-13-44-53.jpeg)
# Ryan BOURA
18/10/23
Premier cours de prototypage et découverte du logiciel openSCAD et ideaMAKER
26/10/2023
Voici les deux choses que j'ai decidé d'imprimer en 3D
Tout d'abord l'objet auquel j'ai pensé est un couteau, voici une image via openscad
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-281.png)
En ce qui concerne les codes j'ai pensé que la façon la plus simple de le faire était d'utiliser des polyèdre en effet la lame est composé de 1 pyramide pour la pointe et de 4 prismes pour la longue
La manche ainsi que la garde sont des rectangle pour rester simple
Image finale en attente
Point de progression : Augmenter la largeur de la manche car elle est en réalité petite même si proportionné sur openscad
Pour mon objet impossible j'ai décidé d'imprimer 3 anneau qui sont imbriqué les uns dans les autres :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-284.png)
Pour les imbriquer j'ai décidé de juste les rotate et de les translater
tentative d’impression des anneaux améliorer le lundi 13 Novembre 2023
translate(\[-5,14,2\]){rotate\_extrude(convexity = 100, $fn = 100)
translate(\[10, 0, 0\])
circle(r = 1, $fn = 100);}
rotate(\[0,30,0\]){ rotate\_extrude(convexity = 100, $fn = 100)
translate(\[10, 0, 0\])
circle(r = 1, $fn = 100);}
translate(\[-12,5,0\]){rotate(\[0,-30,0\]){ rotate\_extrude(convexity = 100, $fn = 100)
translate(\[10, 0, 0\])
circle(r = 1, $fn = 100);};}
Voici le code amélioré avec un peu plus d’espace pour l’impression.
Cependant cela n’a pas marché car il y avait d’autre impression et la machine n’a pas réussi à mettre le physique sur le soluble voir photo
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/photo-2023-11-16-11-37-10.jpeg)
On ne vois que le soluble
07/11/2023 :
Notre mission étant d’imprimer un objet en collaboration avec Sanjay, Héloïse et Maria dans un autre objet la première idée qui nous est venu a l’esprit est quelque chose de type cage, avec le thème d’Halloween on voulait une citrouille et un fantôme dedans. Cependant la nature plate du haut de la citrouille posait des problème on avait peur d’avoir trop de support, donc on a décider de tester avec une sphère simple avec un remplissage de 0 dans lequel on a mis un morceau de PLA puis cette même sphère on l’a mise dans une plus grosse pour tester la transparence.
voici le résultat
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-15-a-18-26-38.png)
10/11
Puis on a codé la sphère finale qui est une sphère avec des cube que l’on a enlever grâce à la fonction de différence
Voci le code :
a=5;
H=0;
R=40;
N=90;
difference() {
difference() {
sphere(r=R-a/2);
for (i=\[1:1:N\]) {
rotate(\[0,0,i\*360/N\]) translate(\[(R-a/2),0,H+a/2\])
cube(\[100,a-4,a\], center=true);
}
};
sphere(r=(R-a/2)-2);};
La majeure différence avec l’ancienne méthode est que cette fois il a fallu enlever la sphère intérieur nous meme et pas juste enlever le remplissage
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/pxl-20231114-180212039.jpg)
Voilà le résultat du dernier test avant l’objet final
13 et 14 novembre 2023 :
objet final et objet à mettre dedans :
l’objet que j’ai décidé de mettre dans la sphère est une étoile de mario (Luma) trouve sur Thingiverse
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/ba9801da-557d-43d6-a808-da4bf2f65fe4.jpeg)
On peut voir l’étoile à gauche qui a été imprimé en même temps que le Renne de Sanjay
et l’objet finale est le suivant avec un stickers pour tester l’adhérence intérieur
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/img-2305.jpeg)
Version finale avec le stokers rouge et blanc ainsi que l’étoile à l’intérieur
07/12/2023
Création d'un système qui active une LED a l'aide d'un Arduino, et une résistance de 200Ohm.
Voici une photo du montage inititiale Voici une photo du montage allumé :
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-12/img-2403.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-12/img-2419n2.jpg)
Puis j'ai décidé de brancher les LED en série et de les faires clignoter grâce au code suivant :
```c++
void setup() {
pinMode(12, OUTPUT);
pinMode(11, OUTPUT);
}
void loop() {
digitalWrite(12, HIGH);
digitalWrite(11, LOW);
delay(500);
digitalWrite(12, LOW);
digitalWrite(11, HIGH);
delay(500);
}
```
voici le montage [](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-12/img-2417n2.jpg)
J'ai ensuite placé en dérivation un buzzer trouvé dans la boite ce qui a donné un montage qui buzzer lorsque le voyant était au rouge
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-12/img-2427.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-12/864img-2425v.jpg)
# Ossian BENGTSSON
### **Seance du 18/10**
Initiation au prototype sur OpenSCAD
### **Impression du 26/10,**
***Première idée de forme*** : entonnoire avec spirale dans le tube mais trop compliqué à imprimer avec les supports à l'intérieur
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/screenshot-2023-10-26-at-16-04-02.png)
code : "
> $fn=100; // Définit la résolution
>
> module spirale(hauteur=100, rayon=10, tours=10) {
> for(i = \[0:0.1:hauteur\]) {
> cylindre\_helice(i, hauteur, rayon, tours);
> }
> }
>
> module cylindre\_helice(pos, hauteur, rayon, tours) {
> angle = 360 \* tours \* pos / hauteur;
> x = rayon \* cos(angle);
> y = rayon \* sin(angle);
> translate(\[x, y, pos\])
> cylinder(r1 = 6, r2 = 0, h = 0.1);
> }
>
> spirale();
>
> cylinder(100,10,10);
>
>
> module tube(externe\_rayon=16.1, interne\_rayon=16, hauteur=97) {
> difference() {
> cylinder(r=externe\_rayon, h=hauteur);
> translate(\[0, 0, -1\]) // Ajustement pour s'assurer que le cylindre intérieur enlève bien toute la matière du haut au bas
> cylinder(r=interne\_rayon, h=hauteur + 2);
> }
> }
>
> tube();
>
>
> // Dimensions de l'entonnoir
> hauteur = 50;
> ouverture\_superieure = 12;
> ouverture\_inferieure = 70;
> epaisseur\_mur = 1; // Épaisseur du mur de l'entonnoir
>
> module entonnoir() {
>
> // Cône extérieur
> difference() {
> cylinder(r1=ouverture\_superieure/2, r2=ouverture\_inferieure/2, h=hauteur);
>
> // Cône intérieur
> translate(\[0, 0, epaisseur\_mur\]) {
> cylinder(r1=(ouverture\_superieure - epaisseur\_mur \* 2)/2, r2=(ouverture\_inferieure - epaisseur\_mur)/2, h=hauteur);
>
> }
> }
> }
>
> // Déplace l'entonnoir à une hauteur de 50 unités
> translate(\[0, 0, 80\]) {
> entonnoir();
> }// Dimensions de l'entonnoir\_2
> hauteur\_2 = 50;
> ouverture\_superieure\_2 = 10;
> ouverture\_inferieure\_2 = 33;
> epaisseur\_mur\_2 = 1; // Épaisseur du mur de l'entonnoir
> module entonnoir\_2() {
>
> // Cône extérieur
> difference() {
> cylinder(r1=ouverture\_superieure\_2/2, r2=ouverture\_inferieure\_2/2, h=hauteur);
>
> // Cône intérieur
> translate(\[0, 0, epaisseur\_mur\_2\]) {
> cylinder(r1=(ouverture\_superieure\_2 - epaisseur\_mur\_2 \* 2)/2, r2=(ouverture\_inferieure\_2 - epaisseur\_mur\_2)/2, h=hauteur\_2);
>
> }
> }
> }
> translate(\[0, 0, -49\]) {
> entonnoir\_2();
> }
>
> "
***Deuxième impression :***
Forme pas imprimable sans imprimante 3D : Cube vide avec 3 cylindre imbriqués qui la traverse.
Plus simple à coder et à imprimer.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/screenshot-2023-10-26-at-16-08-47.png)
## **Séance du 13/11**
Avec Arielle GAL, nous avons pensé à faire une sphère vide avec un manche afin de faire des maracasses avec une pause d'impression afin d'y placer différents objets à l'intérieur.
**Code :**
$fn=200; // Augmenter le nombre de faces pour une sphère plus lisse
R = 40; // Rayon externe de la sphère
epaisseur = 2; // Épaisseur des parois de la sphère
// Créer une sphère vide
difference() {
sphere(R); // Sphère externe
sphere(R - epaisseur); // Sphère interne à soustraire
}
translate(\[0, 0, -80\])cylinder(100,10,20,center=true);
$fn=200; // Augmenter le nombre de faces pour une sphère plus lisse
R = 40; // Rayon externe de la sphère
epaisseur = 2; // Épaisseur des parois de la sphère
// Créer une sphère vide
difference() {
sphere(R); // Sphère externe
sphere(R - epaisseur); // Sphère interne à soustraire
}
translate(\[0, 0, -80\])cylinder(100,10,20,center=true);
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-13-a-17-36-02.png)
# Yasmine Hamed - Prototypage
#### 18/10/23 - **Séance 1**
Découverte de OpenSCAD et IdeaMaker
Découverte du langage Pyhton
#### 26/10/23 - **Séance 2**
Le premier objet que j'ai crée est un stylo avec un bouchon afin de me formaliser avec le code ainsi que openSCAD.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-2023-10-26-161503.png)
J'ai choisi de ne pas imprimer cet objet car j'était plus enthousiaste d'imprimé le second.
Pour le deuxième objet qui est réalisable que par imprimante 3D j'ai pensé tout d'abord à un nœud lié. Je me suis donc tourné vers des maillons de chaines.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-maillon-openscad.png)
J'ai choisi d'imprimé cet objet.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/img-3160.jpg)
Tout c'est très bien passer sauf pour un détail. En effet la gravure que j'avais mise n'a pas été reproduite. On ne voit pas le prénom sur l'objet.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-2023-10-26-162134.png)
#### 14/11/2023 - **Séance 3**
Création d'un jeu pour chat : c'est une sphère avec des trous pour que le chat puisse voir la boule qui se trouve à l'intérieur.
Dans un premier temps j'ai fait la sphère :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-16-110849.png)
```
// Paramètres
sphere_radius = 100;
hole_radius = 25;
num_holes = 8;
// Créer la sphère
difference() {
color("green")
sphere(r = sphere_radius);
// Créer les trous
for (i = [0:num_holes-1]) {
angle = i * 360 / num_holes;
x = sphere_radius * cos(angle);
y = sphere_radius * sin(angle);
translate([x, y, -13])
cylinder(h = 4 * sphere_radius, r = hole_radius, $fn = 100);
}
translate([0, 0, 0])
sphere(sphere_radius-3);
}
```
J'ai ensuite réaliser la boule
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-16-111128.png)
```
difference (){
translate([0, 0, 0])
sphere(40);
translate([0, 0, 0])
sphere(30);
}
```
Je voulais dans un premier temps réaliser la boule puis ensuite en imprimé la sphère avec les trous. Lors de cette deuxième impression je mettrais la boule dans la sphère lors de l'impression.
Apres réflexion concernant l'impression et les supports j'ai décider de tout imprimé d'un seul coup. J'ai fusionné les deux objet dans idea maker.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-16-111711.png)
J'ai ensuite eu l'idée des pendentifs ou il y a des fleurs dedans j'ai donc eu l'idée de faire une sorte de cage à oiseau
Mais comme j'était préoccupé par le fonctionnement du jeu pour chat je me suis arrêté au code de la pièce extérieur.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-16-112434.png)
```
//base de la cage
cylinder(3,17,17);
//barreaux
num_bares = 11;
sphere_radius = 15;
bares_radius = 2;
for (i = [0:num_bares-1]) {
angle = i * 360 / num_bares;
x = sphere_radius * cos(angle);
y = sphere_radius * sin(angle);
translate([x, y, 0])
cylinder(h = 4 * sphere_radius, r = bares_radius, $fn = 100);}
difference() {
translate([0, 0, 4 * sphere_radius])
sphere(17);
translate([-20, -20, 20])
cube(40);
}
difference(){
translate([0, -3.5, 76])
cube([2,7,7]);
translate([0, -2.5, 77])
cube([2,5,5]);
}
```
16/11/2024
j'attend donc le résultats final de l'imprimante.
# Bachir Ammache Prototypage
J'ai utilisé OpenSCAD pour créer une structure de toile d'araignée, démontrant ainsi les capacités de ce logiciel open-source. Cette modélisation 3D de la toile d'araignée a été un exemple convaincant de l'application d'OpenSCAD pour la conception de structures complexes, tout en mettant en évidence les possibilités de personnalisation offertes par ce logiciel.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/iE0image.png)
avec le code suivant :
$fn = 200; // High resolution for smooth lines
web\_radius = 100; // Radius of the entire web
radial\_lines = 16; // Number of radial lines
circle\_count = 10; // Number of circles
circle\_gap = web\_radius / circle\_count; // Distance between circles
web\_height = 5; // Height of the 3D web
// Module to draw radial lines
module draw\_radials() {
for(a = \[0:360/radial\_lines:360-360/radial\_lines\]) {
p1 = \[0, 0\];
p2 = \[web\_radius \* cos(a), web\_radius \* sin(a)\];
draw\_line(p1, p2);
}
}
// Module to draw line
module draw\_line(p1, p2) {
hull() {
translate(p1) circle(0.1);
translate(p2) circle(0.1);
}
}
// Module to draw concentric arcs connecting radials
module draw\_arcs() {
for(i = \[1:circle\_count\]) {
r = i \* circle\_gap;
for(a = \[0:360/radial\_lines:360-360/radial\_lines\]) {
p1 = \[r \* cos(a), r \* sin(a)\];
p2 = \[r \* cos(a + 360/radial\_lines), r \* sin(a + 360/radial\_lines)\];
draw\_line(p1, p2);
}
}
}
// Construct the spider web in 3D
linear\_extrude(height = web\_height) {
draw\_radials();
draw\_arcs();
}
# Soulaimane ZARIOUH
**18/10/23 :** Cours
- Découverte d'OpenSCAD et d'IdeaMaker
- Opérations simples sur OpenSCAD
**27/10/23:**
- Devoirs : Imprimer en 3D un objet original conçu avec OpenSCAD, impossible à construire sans l’impression 3D.
Objet : Sphère emprisonnée dans une cage
**OpenScad**
// Taille du cube
T = 10;
// Épaisseur des arêtes
E = 1;
// Longueur du pavé
L = T + 2;
// Diamètre de la sphère
D = T;
difference() {
// Cube principal
cube(T, center=true);
// Soustraction des pavés pour chaque axe
// Axe X
translate(\[0, 0, 0\])
cube(\[L, T - 2 \* E, T - 2 \* E\], center=true);
// Axe Y
translate(\[0, 0, 0\])
cube(\[T - 2 \* E, L, T - 2 \* E\], center=true);
// Axe Z
translate(\[0, 0, 0\])
cube(\[T - 2 \* E, T - 2 \* E, L\], center=true);
}
// Sphère
sphere(r=D/2, $fn=100);
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/J1qimage.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/iSSimage.png)
La sphère étant trop simplifiée, j'ai trouvé la commande $fn pour améliorer le lissage de celle-ci.
**IdeaMaker**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/Ss5image.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/sl4image.png)
Paramètres de l'impression: Modèle d'imprimante utilisé : RAISE3D E2. Type de filament: PLA de 1.75mm.
Profil d'impression sélectionné: qualité rapide.
Paramètres spécifiques
Hauteur de couche: 0,2500 mm. Densité de remplissage: 10%.
Poids de l'objet imprimé: 8.6
Coût théorique de l'impression: 0.21 S
Temps d'impression prévu initialement : 54 min. Temps d'impression réel: 47 min
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/tyLimage.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/4rhimage.png)
Le bas de la sphère est mal fini, plus de support permettrait de surement une meilleure finition.
**16/11/23 :**
**Titre du Projet : Impression 3D d'un Textile Type "NASA Fabric" en PLA**
**Objectif du Projet :** Créer un objet complexe inspiré du tissu développé par la NASA, composé d'unités hexagonales interconnectées. Ce design devait permettre un certain degré de liberté de mouvement dans une direction, tout en restant rigide dans l'autre.
**Première Tentative :**
- **Paramètres d'Impression :** Mode ultra-rapide, utilisation d'un radeau et de supports partout.
- **Problèmes Rencontrés :**
- Fusion de l'objet avec le radeau, dû à la finesse de la base de l'objet.
- Difficulté d'enlever les supports, surtout dans les mailles fines.
- Utilisation d'un cutter à ultrasons pour essayer de redéfinir les hexagones, mais manque de précision et difficulté d'enlever suffisamment de matière.
**Deuxième Tentative :**
- **Changements Apportés :**
- Suppression du radeau.
- Utilisation d'un support soluble sur l'extrudeuse de droite, PLA multicouleur sur l'extrudeuse de gauche.[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/p4Zimage.png)
- Réglage de la qualité d'impression sur "ultra".
- **Durée d'Impression :** 89 heures.
- **Problème :** En modifiant la qualité d'impression à "Bonne qualité", les paramètres précédents ont été réinitialisés sans que je m'en rende compte.
- **Résultats :**
- Réapparition du radeau.
- Seuls les supports extérieurs ont été imprimés, pas à l'intérieur.
- Supports imprimés en PLA, pas en soluble.
- La transition de couleur n'est pas perceptible en raison de l'utilisation limitée de filament.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/tWGimage.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/CI4image.png)
**Réflexions et Perspectives :** Cette expérience m'a appris l'importance de vérifier attentivement les paramètres d'impression, surtout après des modifications. La qualité d'impression laisse aussi à désirer; une buse d'impression plus fine et un temps d'impression plus long pourrait permettre d'améliorer le rendu. La structure complex rend surement l'utilisation du four compliqué
### Conception du Prototype avec Arduino Uno
#### Objectif du Projet
- **Problématique** : Développer un prototype pour détecter et alerter sur une répartition inégale du poids dans un sac à dos.
- **Utilisation de l'Arduino Uno** : Choisi pour sa facilité d'utilisation, sa communauté de support étendue, et sa compatibilité avec divers capteurs et modules.
#### Choix des Composants
1. **Capteurs de Force Résistifs (FSR)** :
- **Dimension et Type** : Carrés de 4 cm, choisis pour leur taille adéquate et leur capacité à mesurer la force exercée sur les sangles.
- **Justification** : Les FSR sont faciles à intégrer avec Arduino et suffisamment sensibles pour détecter des variations de poids.
2. **Système de Notification par Vibration** :
- **Choix du Feedback Haptique** : Sélectionné pour sa discrétion et sa capacité à communiquer directement avec l'utilisateur sans distraction visuelle ou sonore.
- **Compatibilité avec Arduino** : Les moteurs de vibration sont simples à contrôler via l'Arduino Uno.
#### Conception du Circuit
- **Intégration avec Arduino Uno** : Connexion des FSR et du moteur de vibration à l'Arduino, avec les résistances nécessaires pour assurer une lecture précise des capteurs.
- **Schéma du Circuit** : Conception d'un schéma clair pour documenter la connexion des composants.
#### Développement du Logiciel
- **Programmation avec Arduino** : Écriture du code pour lire les données des FSR et activer le moteur de vibration lorsque la répartition du poids est inégale.
- **Seuils de Déclenchement** : Définition des seuils pour les alertes basée sur des tests préliminaires et des données biomécaniques.
#### Tests et Validation
- **Prototypage** : Assemblage du circuit sur une breadboard pour des tests initiaux.
- **Tests de Charge** : Utilisation de poids standard pour calibrer et tester la précision des FSR.
- **Ajustements du Code** : Optimisation du code pour améliorer la réactivité et la fiabilité des notifications.
.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-12/tDnimage.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-12/BQ9image.png)
```
const int vibpin1 = 4;
const int buttonpin= 2 ;
const int vibpin2 = 5;
int button_state=0;
int enable_state=0;
int i =0; // last button state
int sensorVal1= 0;
int sensorVal2= 0;
float voltage1 = 0 ;
float voltage2 = 0 ;
float delta = 0;
int current_buttonState;
int oldState =0 ;
int butval=0;
unsigned long lastDebounceTime = 0; // the last time the output pin was toggled
unsigned long debounceDelay = 50;
void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
pinMode(vibpin1, OUTPUT);
pinMode(buttonpin, INPUT_PULLUP);
pinMode(vibpin2, OUTPUT);
}
void loop() {
// put your main code here, to run repeatedly:
//button_state = digitalRead(buttonpin);
if (digitalRead(buttonpin)== HIGH && !button_state ){
enable_state =1;
button_state = !button_state;
delay(500);
}
if (digitalRead(buttonpin)== HIGH && button_state ){
enable_state =0;
button_state = !button_state;
delay(500);
}
/*
if (button_state ==1) {
// reset the debouncing timer
enable_state= 1 ;
}else{
enable_state=0 ;
}
*/
if (enable_state==1 ){
sensorVal1= analogRead(A0);
sensorVal2= analogRead(A1);
voltage1 = sensorVal1*(5.0/1023) ;
voltage2 = sensorVal2*(5.0/1023) ;
delta = abs(voltage1-voltage2) ;
Serial.println(delta);
delay(200);
if (delta>0.8){
if (voltage1 > voltage2){
digitalWrite(vibpin1, HIGH);
delay(100);
digitalWrite(vibpin1, LOW);
}else if (voltage2>=voltage1){
digitalWrite(vibpin2, HIGH);
delay(100);
digitalWrite(vibpin2, LOW);
}
}else if (delta<=0. && delta>0.2 && voltage1>0.2 && voltage2>0.2){
digitalWrite(vibpin1, HIGH);
digitalWrite(vibpin2, HIGH);
delay(500);
digitalWrite(vibpin1, LOW);
digitalWrite(vibpin2, LOW);
delay(1500);
enable_state=0;
button_state = !button_state; // pas sur
}else{
digitalWrite(vibpin1, LOW);
digitalWrite(vibpin2, LOW);
}
// end if enable state
}
}
```
# Ishika PATEL
##### **18/10/23 :** Première séance de processus d'innovation
Introduction de l'UE Processus d'innovation
- Découverte de OpenSCAD et IdeaMaker
Sur OpenSCAD, pour se familiariser avec le logiciel, on a réalisé un cylindre comportant au-dessus 10 cubes. De plus, on a appris à utiliser l'addition et la différence.
##### **26/10/23** : Prototype 3D
On nous a demandé de réaliser un objet uniquement réalisable en impression 3D.
J'ai choisi d'imprimer une **fleur en 3D**.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-2023-10-26-a-20-23-07.png)
Sur IdeaMaker, j'ai tout d'abord mis pour la dimension 3D avec x = 5cm. En revanche, il demandait beaucoup de temps avec environ 1h19min d'impression. Pour réduire le temps d'impression, j'ai donc réduit les dimensions avec x = 3cm. Au final, l'impression 3D a duré uniquement 27 min.
L'impression s'est très bien déroulé.
Vers le dessus, on observe que le remplissage n'est pas net au début de l'impression mais vers la fin elle est plus lisse.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/img-7066.jpg)
##### **27/10/23** Deuxième séance de processus d'innovation
- Présentation des objets en impression 3D, les améliorations possibles à faire pour nos objets grâce aux différentes méthodes et différents matériaux
##### **14/11/23** : Impression 3D d'un diamant
Réalisation d'un objet utilisant une autre couleur, un autre matériau que le PLA, un objet dans un objet
J'ai prototypé un **diamant avec du PLA transparent**
Voici le code sur OpenSCAD :
```
function make_facets(start,increment,limit,axial_angle,height) =
start <= limit
? concat([[start/limit*360, axial_angle, height]] ,
make_facets(start+increment,increment,limit,axial_angle,height))
: [] ;
// CORPS DU DIAMANT
module body(Size=100) {
cube(Size,center=true);
}
module cut_facet_data(index_angle,axial_angle,height,Width=200,Depth=50) {
rotate([0,0,index_angle])
rotate([0,axial_angle,0])
translate([0,0,Depth/2 + height])
cube([Width,Width,Depth],center=true);
}
module cut_facets(facets, n) {
for (i =[0:n-1])
cut_facet(facets[i]);
}
module cut_facet(facet) {
cut_facet_data(facet[0],facet[1],facet[2]);
}
// FACE DES DIAMANT
module gem(facets,n) {
difference() {
if (n==1) body(); else gem(facets,n-1);
cut_facet(facets[n-1]);
}
}
// BRILLANCE DU DIAMANT
function brilliant_facets() =
concat(
make_facets(1,1,1,0,2.28),
make_facets(1,1,1,180,7.8),
make_facets(1,2,32,35,5),
make_facets(4,4,32,30,4.46),
make_facets(2,4,32,16,3.46),
make_facets(2,2,32,90,8.5),
make_facets(1,2,32,42+180,6)
);
facets = brilliant_facets();
scale(3) gem(facets,len(facets));
```
Le diamant devrait ressembler à l'image ci-dessous :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-13-a-22-20-13.png)
Sur IdeaMaker, j'ai choisi que la densité de remplissage sera de 10%. Vu que mon objet sera transparent je souhaite que à l'intérieur ça soit vide. A voir si cela à marcher à l'impression 3D ou s'il faut modifier. L'impression 3D a duré 2h30 avec un autre objet mis à côté pour l'impression, afin de gagner du temps et ne pas occuper plusieurs machines en même temps. J'ai décidé cette fois-ci d'utiliser du PLA transparent pour représenter au mieux un diamant.
Impression 3D de l'objet:
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/img-7605.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/img-7603.jpg)
Malheureusement, la pointe du diamant n'est pas présente et a fait un trou à la place. Je suis quand même satisfaite du résultat malgré la pointe manquante. Sur IdeaMaker, j'aurais dû inverser la position du diamant pour avoir un meilleur résultat. On voit quand même les traces de l'impression 3D. De plus, je voulais que l'intérieur soit vide, j'ai configuré les paramètres avec un remplissage de 10%. J'étais sceptique à l'idée de mettre à 0% le remplissage.
POST-TRAITEMENT : [https://www.youtube.com/watch?v=Jv-CbnB8Uz4&t=83s](https://www.youtube.com/watch?v=Jv-CbnB8Uz4&t=83s)
Avec Maeva, nous avons vu une méthode post-traitement qui consiste à lisser l'objet pour le rendre brillant grâce à l'immersion dans l'acétone. Si j'ai l'occasion je souhaiterais le faire.
##### **16/11/23** : Troisième séance de processus d'innovation
Introduction à l'Arduino
##### **8/12/23** : Quatrième séance de processus d'innovation
# Camille Chen
Séance 18/10/2023
Première séance nous avons appris à utiliser l'outil OpenScad. Voici ce qu'on a fait :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/KqQimage.png)
Le programme est le suivant :
*d=5;*
*a=10;*
*color("blue") cube(a,center=true);*
*for(i=\[1:1:10\]) {*
*translate(\[i\*(a+d),0,0\]) color("cyan") cube(a,center=true);*
*}*
C'était la première chose que nous avions faites : des cubes alignés.
Ensuite, nous avons fait un cylindre avec au sommet des cubes pour faire une tour. Ensuite, je me suis permise de le décorer un peu à ma guise, voici le résultat :
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/0xmimage.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/PLaimage.png) [](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/cfgimage.png)
Le programme est le suivant :
*d=5;*
*a=10; // arrête des cubes*
*H=100; // hauteur de la tour*
*R=40; // rayon de la tour*
*N=10; // nombre de cubes*
*color("blue") cube(a,center=true);*
*for(i=\[1:1:N\]) {*
*rotate(\[0,0,i\*360/N\]) translate(\[(R-a/2),0,H+a/2\]) color("beige") cube(a,center=true);*
*color("turquoise") cylinder(h=H,r=R);*
*}*
*color("white") rotate\_extrude(convexity=100)*
*translate(\[67,40,52\])*
*circle(r=10,$fn=100);*
*t=" Welcome to Paradise";*
*color("lightskyblue") linear\_extrude(15) {*
*text(t,50);*
*}*
*color("darkslategray") {*
*linear\_extrude(2) {*
*offset(4) {*
*fill() {*
*text(t,50);*
*}*
*}*
*}*
*}*
Le but de cette première séance a été de nous familiariser avec ce nouvel outil. J'ai donc laissé mon esprit créatif prendre place.
27/10/2023 : 2e séance
Pour cette séance, il fallait créer des objets qu'on voulait. J'ai choisi de créer un porte-clé car j'ai récemment cassé le mien.
Voici le résultat :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/cHUimage.png)
En réalité, ça donne ceci étant donné que j'ai beaucoup réduit la taille et que je n'ai pas choisi la couleur de la bobine que je voulais utiliser pour l'imprimante 3D.
Le programme est le suivant :
*$fn=127;*
*text1="Life is short";*
*text2="Like";*
*text3="you :)";*
*color("skyblue") difference(){*
*union(){*
*translate(\[-20,-3,0\]) cube(\[50,40,2\]);*
*hull(){*
*translate(\[-50-5,0,0\])cylinder(r=5,h=2);*
*translate(\[50+5,0,0\])cylinder(r=5,h=2);*
*translate(\[-50-5,40-5,0\]) cylinder(r=5,h=2);*
*translate(\[50+5,40-5,0\]) cylinder(r=5,h=2);*
*}*
*linear\_extrude(height=3.5){*
*translate(\[0,20,0\]) text(text1, size=10, halign="center", font="InkFree:style=bold");*
*translate(\[-15,10,0\]) text(text2, size=10, halign="center", font=signfont,font="InkFree:style=bold");*
*translate(\[17,10,0\]) text(text3, size=10, halign="center", font=signfont,font="Elephant:style=bold");*
*}*
*}*
*translate(\[-50-3,33,-0.5\])cylinder(r=2.5,h=3);*
Pour mon deuxième objet, je n'avais pas d'idée donc j'ai laissé mon imagination faire, et je me suis arrêtée à ça car je n'avais plus d'idée.
 
Puisque j'ai beaucoup diminué la taille de mon objet, j'ai eu un petit problème sur le haut de ma tour : en effet, je n'ai pas obtenu les diamants que je voulais en haut de ma tour puisque leur taille était minuscule.
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/dt.jpg)
Le programme est le suivant :
*// Parameters*
*base\_height = 2; // Height of the base*
*base\_radius = 30; // Radius of the base*
*platform\_height = 3; // Height of the platform*
*platform\_radius = 22; // Radius of the platform*
*rotation\_height = 2; // Height of the rotation cylinder*
*rotation\_radius = 15; // Radius of the rotation cylinder*
*// Base*
*color("lightcyan") cylinder(h = base\_height, r1 = base\_radius, r2 = base\_radius);*
*// Platform*
*translate(\[0, 0, base\_height\])*
*color("steelblue") cylinder(h = base\_height, r1 = platform\_radius, r2 = platform\_radius);*
*// Rotation Cylinder*
*translate(\[0, 0, base\_height + base\_height\])*
*color("lightskyblue") cylinder(h = rotation\_height, r1 = rotation\_radius, r2 = rotation\_radius);*
*// Hole for Insert*
*d=4;*
*a=1;*
*H=15;*
*R=4;*
*N=15;*
*union(){*
*for(i=\[1:1:N\]){*
*rotate(\[0,0,i\*360/N\]) translate(\[(R-a/2),0,H+a/2\]) color("beige") sphere(a,center=true);*
*}*
*color("dodgerblue") cylinder(h=H,r=R);*
*}*
*color("blue"){*
*linear\_extrrude(2){*
*offset(4) {*
*}*
*}*
*}*
Pour la séance du 16/11/2023 :
On devait faire pour la séance dernière un objet réalisable que en imprimante 3D. Après avoir visionné un film d'action, j'ai été fascinée par une scène où une balle était tirée d'un pistolet. Les images reflétée était incroyablement belles avec des perspectives captivantes. La trajectoire de la balle a traversé un cube posé sur la table, et ce dernier a été transpercé sous différentes couches, ce qui m'a donné l'idée de créer l'objet suivant :
 
Le programme pour réaliser ce cube est le suivant :
*$fn=50;*
*difference() {*
*color("lightcyan") cube(10,center=true);*
*cylinder(r=4.5,h=12,center=true);*
*rotate(\[90,0,0\]) cylinder(r=4.5,h=12,center=true);*
*rotate(\[0,90,0\]) cylinder(r=4.5,h=12,center=true);*
*}*
*difference() {*
*color("paleturquoise") cube(8,center=true);*
*cylinder(r=3.5,h=12,center=true);*
*rotate(\[90,0,0\]) cylinder(r=3.5,h=12,center=true);*
*rotate(\[0,90,0\]) cylinder(r=3.5,h=12,center=true);*
*}*
*difference() {*
*color("skyblue") cube(6,center=true);*
*cylinder(r=2.5,h=12,center=true);*
*rotate(\[90,0,0\]) cylinder(r=2.5,h=12,center=true);*
*rotate(\[0,90,0\]) cylinder(r=2.5,h=12,center=true);*
*}*
*difference() {*
*color("lightsteelblue") cube(4,center=true);*
*cylinder(r=1.5,h=12,center=true);*
*rotate(\[90,0,0\]) cylinder(r=1.5,h=12,center=true);*
*rotate(\[0,90,0\]) cylinder(r=1.5,h=12,center=true);*
*}*
Concernant l'objet à réaliser dans lequel on doit déposer un objet PENDANT l'impression 3D (ce qui inclue l'arrêt de l'impression 3D de notre produit en cours), j'ai pensé à un pot fermé.
En approfondissant mes recherches, j'ai décidé de faire un objet comme un porte crayons puisque je perds toujours mes crayons et stylos à la maison...
Voici à quoi ressemble mon pot de crayons :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/cD2image.png)  
Voici le programme qui en résulte :
*Diametre=50;*
*Hauteur=150;*
*Qualite=6;*
*Nb\_barreaux=32;*
*Epaisseur\_barreaux=2;*
*Decalage=5;*
*Epaisseur\_fond=6;*
*for(i=\[1:Nb\_barreaux\]) color("lightskyblue")*
*{*
*hull()*
*{*
*rotate(\[0,0,360/Nb\_barreaux\*i\])*
*translate(\[Diametre/2,0,0\])*
*color("lightskyblue") sphere(d=Epaisseur\_barreaux,$fn=Qualite);*
*rotate(\[0,0,360/Nb\_barreaux\*(i+Decalage)\])*
*translate(\[Diametre/2,0,Hauteur\])*
*sphere(d=Epaisseur\_barreaux,$fn=Qualite);*
*}*
*hull()*
*{*
*rotate(\[0,0,360/Nb\_barreaux\*i\])*
*translate(\[Diametre/2,0,0\])*
*sphere(d=Epaisseur\_barreaux,$fn=Qualite);*
*rotate(\[0,0,360/Nb\_barreaux\*(i-Decalage)\])*
*translate(\[Diametre/2,0,Hauteur\])*
*sphere(d=Epaisseur\_barreaux,$fn=Qualite);*
*}*
*}*
*translate(\[0,0,-Epaisseur\_barreaux\])*
*color("lightcyan") cylinder(d=Diametre+Epaisseur\_barreaux\*2,$fn=Nb\_barreaux,h=Epaisseur\_fond);*
*translate(\[0,0,Hauteur-Epaisseur\_barreaux\])*
*color("lightcyan") cylinder(d=Diametre+Epaisseur\_barreaux\*2,$fn=Nb\_barreaux,h=Epaisseur\_fond);*
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/UYKimage.png)
# EL NOUEIRY Marya - Impressions 3D
##### **Impression 3D - 26 Octobre 2023**
Aujourd'hui, j'ai eu l'opportunité de mettre en pratique ce que j'ai appris lors du cours d'introduction au prototypage du 18 octobre. L'objectif était de créer des prototypes en utilisant l'impression 3D et de documenter le processus, voici comment tout s'est déroulé.
J'ai décidé de créer deux objets différents pour expérimenter davantage avec l'impression 3D. Mon premier choix était une bouteille stylisée, tandis que le second objet était un cube comportant un cône imbriqué à l'intérieur, créant un design intéressant.
Tout a commencé par la phase de conception sur un logiciel de modélisation OpenScad. ; j'ai créé des fichiers .STL pour chaque objet, en veillant à ce que les mesures et les dimensions soient précises. Une fois les fichiers prêts, j'ai transféré les modèles sur l'ordinateur qui contrôlait l'imprimante 3D. J'ai utilisé du PLA pour mon impression.
L'imprimante 3D a commencé à produire mes objets couche par couche. Le processus a été fascinant à observer, et il a fallu un peu de temps pour imprimer les deux prototypes. Après l'impression, j'ai retiré soigneusement les objets de la plateforme d'impression et éliminé tout support inutile.
**Résultats et Images :**
Vous trouverez ci-dessous des images des prototypes imprimés, ainsi que des photos des modèles en 3D pour mieux comprendre le processus :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/vufimage.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/rjCimage.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/l79image.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/mrmimage.png)
Cette expérience d'impression 3D au FabLab m'a permis de mieux comprendre le prototypage et la fabrication additive, ainsi que les avantages de l'impression 3D en tant qu'outil de conception.
##### **Impression 3D - 16 Novembre 2023**
##### **Test d'une sphère dans une sphère (Avec Eloise, Ryan et Sanjay)**
En codant une simple sphère sur OpenScad, et en la vidant de son remplissage sur Idea maker nous avons réussit a imprimer uniquement la coque de la sphère. Ensuite, nous avons réimprimé la même sphère avec un PLA transparent en y plaçant notre première petite sphère dans le but de savoir si la technique était possible avec une sphère de taille plus importante mais aussi pour tester le PLA transparent.
##### **Code :**
$fn=1000; // Augmenter le nombre de faces pour une sphère plus lisse
d=5;
a=5;
H=0;
R=40;
N=90
difference() {
difference() {
sphere(r=R-a/2);
for (i=\[1:1:N\]) {
rotate(\[0,0,i\*360/N\]) translate(\[(R-a/2),0,H+a/2\])
cube(\[100,a-4,a\], center=true);
}
};
sphere(r=(R-a/2)-2);};
##### **Résultat final :**
Notre sphère est de 5cm de diamètre et contient une sphère de 2cm de diamètre en jaune a l'intérieur.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-15-a-18-26-38.png)
Étant donné que le test de la sphère dans un sphère fût concluant, nous avons réitérer le test mais cette fois ci de manière plus complexe en y insérant des trous pour visualiser davantage l'objet a l'intérieur mais toujours avec un PLA transparent. Nous avons décidé d'imprimer cette sphère en 4 copies pour que chacun ait la sienne en y insérant l'objet de notre choix.
J'ai choisi d'imprimer un **flocon de neige bicolore** : Une face en blanc et l'autre face en rouge pour placer a l'intérieur de la sphère.
Lien thingiverse du flocon :
[https://www.thingiverse.com/thing:12034](https://www.thingiverse.com/thing:12034)
##### **Visualisation sur idea maker :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/pdQimage.png)
Au moment de l'impression, pour libérer des imprimantes et optimiser le temps, j'ai décidé d'imprimer mon objet sur le même plateau que 2 autres personnes qui voulaient imprimer un objet à l'aide des mêmes bobines.
Cependant, l'impression a échoué car un des objet imprimé était trop peu stable et a donc perturbé l'impression de tous les objets du plateau. De ce fait, par manque de temps pour imprimer un nouvel objet, j'ai décidé de ne mettre que des bouts de plastique PLA oranges, trouvés au fablab, à l'intérieur de ma sphère.
##### **Processus d'impression :**
1\) Lancement de l'impression de la sphère de 5cm de diamètre
2\) Arrêt de l'impression lorsque 1/4 de la sphère s'est formée (Ou on aurait pu optee pour une planification **paramètres avancées** sur IdeaMaker nous permettant de planifier une pause a l'hauteur souhaitée)
3\) Insertion des bouts de PLA dans la sphère
4\) Reprise et fin de l'impression de la sphère
**Le résultat final après décrochage du support :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/whatsapp-image-2023-11-16-at-14-17-07-6b8c06da.jpg)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/whatsapp-image-2023-11-16-at-14-17-10-cb9e7749.jpg)
# Rita Matar
##### **Cours :** **18 Octobre 2023**
- Découverte d'**OpenSCAD** et de son language pour créer un objet 3D.
- Matérialisation de l'objet sur **Ideamaker** pour transférer sur une imprimante 3D
##### **26 Octobre 2023**
- Créer des objets en utilisant la différence, la translation et l'union
- Lors de notre première séance, j'ai eu l'occasion de m'initier à l'utilisation d'une **imprimante 3D**.
Pour préparer l'impression, j'ai appliqué les enseignements que j'ai acquis lors du cours du 18 octobre 2023 sur Openscad. Cela m'a permis de créer deux objets : l'un assez ordinaire et l'autre plutôt original.
**Objet ordinaire** -> Verre à Pied :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-2023-10-27-a-16-22-25.png)
**Objet Original** -> Sphère dans une pyramide :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-2023-10-27-a-16-22-33.png)
J'ai choisi de n'imprimer que le premier objet, car imprimer les deux demandait beaucoup de temps, environ 1 heure pour le verre à pied seul, et 5 heures pour les deux. Une solution pour réduire le temps aurait été de réduire la taille, mais je tenais à ce que le verre à pied ait une taille d'au moins 4 cm, c'est pourquoi j'ai opté pour l'impression d'un seul objet.
L'impression s'est bien déroulée, et le retrait du support et des soutiens n'a pas été difficile grâce aux pinces mises à disposition dans le FabLab.
**Résultat final **du Verre à Pied :
**[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/img-5485.jpg)**
**Conclusion**
Cette **première expérience** avec les imprimantes 3D du FabLab à été très agréable et instructif, cela ma permis d'avoir un avant gout et une **première compréhension** de la fabrication 3D et du prototypage.
##### **Cours : 27 octobre 2023**
Pour la manipulation de deux filaments différents : dans ideaMaker, la configuration des deux **extrudeurs** de la machine (gauche et droite) peut être ajustée lorsque l'on utilise deux matériaux distincts. Les paramètres nécessaires peuvent être adaptés en dupliquant le code existant, en le divisant en deux, puis en insérant le nouvel objet à imprimer à côté de l'objet précédent sur ideaMaker.
- **Post-traitements** :
- Sable : prenez l'objet imprimé, placez-le dans un récipient avec du sable, tassez-le, puis mettez-le au four à 110 °C. Le PLA se ramollira légèrement, favorisant une meilleure adhérence entre les couches
- Solvant : l'évaporation avec la chaleur permet d'obtenir de la transparence, particulièrement efficace avec des filaments transparents
- **Devoirs** :
- Créez un objet pour lequel vous mettez l'impression en pause, puis insérez un autre objet à l'intérieur avant de reprendre l'impression
- Utiliser différentes couleur de files pour colorer un objet 3D
##### **15 octobre 2023**
Au vu de la période de l'année dans laquelle on se trouve j'ai décidé d'imprimer une boule de Noël **bi-colore** et d'insérer un grelot à l'intérieur.
**Boule de Noël** -> visualisation sur Openscad **Grelots à insérer**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-12-a-19-30-03.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/img-5624.jpg)
Lors de l'étape d'impression nous avons pris la décision avec deux de mes camarades d'imprimer nos objets en même temps, afin de libérer des imprimantes et de gagner du temps. Malheureusement, l'impression a rencontré un échec en raison de l'instabilité de mon objet 3D par **manque de support**. Perturbant ainsi l'ensemble du processus d'impression sur le plateau.
En arrivant au Fablab pour récupérer nos objet, on nous a expliqué que nos objets on été jeté nous n'avons donc pas pu prendre le "résultat" en photo. Par **manque de temps** je n'ai pas pu imprimer de nouvel objet.
**Conclusion**
Cette expérience souligne l'importance de la **planification** minutieuse et de la **stabilité** des modèles 3D, tout en rappelant la nécessité de **gérer efficacement le temps disponible** dans des environnements comme le Fablab
Bien que le résultat n'ait pas été conforme à mes attentes, cette expérience a néanmoins enrichi ma compréhension des défis liés à l'impression 3D et m'a incité à envisager des améliorations pour de futures collaborations dans des projets similaires.
##### **Cours : 16 Novembre 2023**
- Introduction à l'**ARDUINO** :
- cartes électroniques programmables (donc dotées d'un processeur et de mémoire) sur lesquelles nous pouvons brancher des capteurs de température, d'humidité, de vibration...
##### **Cours : 8 Décembre 2023**
# Sanjay APAVOU
**18/10/23**
Première séance prototypage et initiation avec d'un logiciel de code en 3D openSCAD et ideaMAKER pour imprimer nos objets
**26/10/2023**
Voici les deux objets que j'ai imprimé en 3D
Le premier étant une gourde cylindrique avec le bas de la gourde plus fin que le haut. L'intérieur étant creuser avec la fonction translate.
De plus j'ai rajouté un bouchon sphérique a l'intérieur d'un cylindre pour fermer cette gourde grâce a la fonction union puis translate pour visualiser si le bouchon correspondait bien au diamètre de la gourde. Cependant, j'aurais pu agrandir le trou dans la gourde pour améliorer sa contenance.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/zgzimage.png)
Le deuxième objet que j'ai choisi de faire était a la base une bague en forme d'hélice double brin d'ADN cependant je n'ai pas réussi a faire la bague alors je me suis contenté de faire uniquement la double hélice d'ADN sur un support, plus un objet de décoration qu'une bague… Je me suis inspiré d'un code qui existait déjà que j'ai modifié pour ajouter le socle et faire les brins de manière plus réaliste. Cependant lors de l'impression, beaucoup de support était nécessaire pour que l'objet s'imprime correctement. Peut être qu'en utilisant un support issu de matériaux solvable en solution cela aurait été plus simple pour retirer les support.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/BXFimage.png)
**Code ADN : **
```c++
// VARIABLES
// hauteur helix
helix_height=150;
// Degrés de rotation
twist_amount=360.0;
/* bras */
// Distance du centre aux bras
arm_distance=23;
// Épaisseur des bras
arm_thickness=15;
// Largeur des bras
arm_width=.35;
// Angle pour décaler un bras afin qu'ils ne soient pas alignés.
arm_offset=45;
/* Poutres transversales */
// Hauteur de la poutre
beam_height=3;
// Largeur de la poutre
beam_width=6;
// Arrondi de la poutre
beam_roundness=1.5;
// Nombre de poutres
num_beams=10.0;
/* Base */
// Hauteur de la base
base_height=5;
// Rayon de la base
base_radius=37;
// Ratio du rayon supérieur au bas de la base
base_taper=.95;
module roundedcube(xx, yy, height, radius) {
difference(){
cube([xx,yy,height]);
difference(){
translate([-.5,-.5,-.2])
cube([radius+.5,radius+.5,height+.5]);
translate([radius,radius,height/2])
cylinder(height,radius,radius,true);
}
translate([xx,0,0])
rotate(90)
difference(){
translate([-.5,-.5,-.2])
cube([radius+.5,radius+.5,height+.5]);
translate([radius,radius,height/2])
cylinder(height,radius,radius,true);
}
translate([xx,yy,0])
rotate(180)
difference(){
translate([-.5,-.5,-.2])
cube([radius+.5,radius+.5,height+.5]);
translate([radius,radius,height/2])
cylinder(height,radius,radius,true);
}
translate([0,yy,0])
rotate(270)
difference(){
translate([-.5,-.5,-.2])
cube([radius+.5,radius+.5,height+.5]);
translate([radius,radius,height/2])
cylinder(height,radius,radius,true);
}
}
}
// CALCULATIONS
beam_length=arm_distance*2-arm_thickness*.5;
beam_twist=twist_amount/(num_beams+1.0);
beam_delta=helix_height/(num_beams+1.0);
beam_offset=arm_offset*.5;
module arm_footprint(helix_r=50
,arm_r=10
) {
skinny_arm = arm_r * arm_width;
union() {
translate([ -helix_r + skinny_arm * .5,0])
square([skinny_arm,arm_r],center=true);
rotate([0,0,arm_offset])
translate([ helix_r - skinny_arm * .5,0])
square([skinny_arm,arm_r],center=true);
}
}
module helix_coil(helix_r=100
, arm_r=10
, helix_h=100
) {
linear_extrude(height=helix_h, convexity=10, twist=-twist_amount, slices=500)
arm_footprint(helix_r=helix_r
,arm_r=arm_r
);
}
// BASE
linear_extrude(height=base_height, scale=base_taper) circle(r=base_radius, $fn=400 );
// ARMS
translate([0, 0, base_height])
helix_coil(helix_h=helix_height
,arm_r=arm_thickness
,helix_r=arm_distance
);
// BEAMS
translate([0, 0, base_height])
for ( i = [1:1:num_beams])
rotate([0,0,beam_twist*i])
translate([-.5*beam_length,
-.5*beam_width,
.5*beam_height + beam_delta*i])
rotate([0,90,beam_offset]) //beam
roundedcube(beam_height,beam_width,beam_length,beam_roundness);
//rotate([0,0,-45])
//translate([100,0,0])
//cube([5,50,5], center=true);
```
**27/10/2023 :**
Il nous a été demandé d'améliorer nos objets en utilisant différentes techniques présenté en cours notamment en utilisant deux filaments par exemple.
Je pense modifier le code de la gourde pour la rendre plus profonde et faire le bouchon d'une autre couleur que la boule.
Pour l'ADN je pense utiliser la technique des supports soluble
Enfin il nous a été demandé de faire un troisième objet dans lequel nous devions mettre un objet dedans en arrêtant l'impression.
**07/11/2023 :**
Test de la sphère dans une sphère :
En codant une simple sphère sur open scad, et en la vidant de son remplissage sur idea maker nous avons réussit a imprimer uniquement la coque de la sphère. Nous avons a la suite réimprimer la même sphère avec un,PLA transparent en y plaçant notre première petite sphère. Nous avons fait cela car nous voulions voir si la technique était possible avec une sphère de taille plus importante mais aussi pour tester le PLA transparent. Ici nous avons une sphère de 5cm de diamètre avec une sphère de 2cm de diamètre en jaune a l'intérieur.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/pxl-20231109-141555314.jpg)
**10****/11/2023 :**
Nous avons réitérer le test de la sphère mais cette fois ci de manière plus complexe en y insérant des trous pour visualiser davantage l'objet a l'intérieur mais toujours avec un pla transparent. Voici le code que nous avons utilisé :
```c++
$fn=100; // Augmenter le nombre de faces pour une sphère plus lisse
d=5;
a=5;
H=0;
R=40;
N=90;
difference() {
difference() {
sphere(r=R-a/2);
for (i=[1:1:N]) {
rotate([0,0,i*360/N]) translate([(R-a/2),0,H+a/2])
cube([100,a-4,a], center=true);
}
};
sphere(r=(R-a/2)-2);};
```
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/pxl-20231114-180212039.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/cSZimage.png)
Voici la boule imprimer avec des morceaux de pla bleu dedans ainsi qu'une visualisation 3D avec idea maker.
Pour mettre les morceaux de pla nous avons juste mis l'impression sur pause.
A la suite nous avons en groupe imprimer 4 fois la même boule en y introduisant chacun un objet différent. Pour ma part j'ai choisi d'y introduire un [renne](https://www.thingiverse.com/thing:1168292 "rennes en 3D") jaune fluo pour qu'il soit visible a l'intérieur. Cependant je lui ai enlevé les pattes après l'impression sans faire exprès car l'ayant imprimer en petit elles étaient un peu fragile. Nous avons eu beaucoup de chances car l'imprimante c'est mis en pause seul a quasiment 3 quart de hauteur en raison de l'absence de fil ce qui nous a permis de mettre nos objets et de relancer.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/mmHimage.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/photo-2023-11-16-11-46-30.jpeg)
**07/12/2023 : **
En collaboration avec Ryan nous avons fait un Arduino avec 3 [leds](https://photos.app.goo.gl/5b4Nbt3fQFuqyXfBA) qui clignotes en utilisant le code suivant :
```c++
void setup() {
pinMode(12, OUTPUT);
pinMode(11, OUTPUT);
pinMode(8, OUTPUT);
}
void loop() {
digitalWrite(12, HIGH);
digitalWrite(11, LOW);
digitalWrite(8, LOW);
delay(500);
digitalWrite(12, LOW);
digitalWrite(11, HIGH);
digitalWrite(8, LOW);
delay(500);
digitalWrite(12, LOW);
digitalWrite(11, LOW);
digitalWrite(8, HIGH);
delay(500);
}
```
**Merci Ryan pour le débug**
# Eloïse Filley
### **PROTOTYPAGE**
#### **18 / 10 / 2023 - 1ère séance au FabLab**
##### **Introduction au prototypage**
- Découverte du logiciel de code : openSCAD
- Découverte du logiciel d'impression 3D : ideaMaker
##### **Pour la fois suivante**
1. Imprimer un objet de notre choix
2. Imprimer un objet infaisable sans imprimante 3D
#### **25 / 10 / 2023 - Impression 3D**
##### **1) Imprimer un objet de notre choix**
Mon objet est un bouton de veste que j'ai codé à laide du logiciel open SCAD et que j'ai imprimé en 3D à l'aide du logiciel ideaMaker. J'ai choisi d'ajouter un rebord à mon bouton pour le rendre un peu plus complexe et plus design. J'ai inséré 4 cylindre au cendre de mon bouton pour compléter la forme de mon objet.
Cependant, j'aurai pu compéter davantage mon bouton en codant des trous sur le logiciel openSCAD grâce à la commande difference() pour pouvoir coudre mon bouton à l'issue de l'impression.
##### **Code :**
DiametreBouton = 24;
Epaisseur = 2;
DiametreTrous = 4;
DiametreRebord = 20;
EpaisseurRebord = 1;
//$fs is the minimum size of a fragment
module boutonDeVeste() {
union() {
color("black") cylinder(h = Epaisseur, d = DiametreBouton, $fn = 100);
color("beige")
translate(\[0, 0, 2\]) cylinder(h = EpaisseurRebord, d= DiametreRebord, $fn = 100);
// Crée les trous
for (i = \[0:3\]) {
angle = i \* 90;
color("brown")
translate(\[cos(angle) \* (DiametreBouton / 5), sin(angle) \* (DiametreBouton / 5), 1\])
rotate(\[0, 0, angle\])
cylinder(h = Epaisseur +1, d = DiametreTrous, $fn = 100);
}
}
}
// Affiche le bouton
boutonDeVeste();
##### **Résultat sur open SCAD :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/Kdrimage.png)
##### **Résultat final :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/TOyimage.png)
##### **2) Imprimer un objet infaisable sans imprimante 3D**
Mon objet est un smiley dont j'ai récupéré le code déjà existant que j'ai modifié pour choisir le caractère du visage puis je l'ai imprimé en 3D à l'aide du logiciel ideaMaker.
Cependant, j'ai pris beaucoup de temps à comprendre le code pour pouvoir ensuite le modifier.
##### **Code :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/navimage.png)
##### **Visualisation sur idea maker :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/qkVimage.png)
##### **Résultat final :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/4J7image.png)
##### **27 / 10 / 2023 - 2ème séance au FabLab**
##### **Améliorer nos objets imprimés**
**Pour travailler avec 2 filaments différents :** dans ideaMaker, on peut spécifier aux 2 extrudeurs de la machines (gauche et droite) si on utilise 2 matériaux différents, les valeurs changent. On peut garder le même code, le couper en 2 puis insérer le nouvel objet à créer et l'insérer à côté de l'ancien sur ideaMaker.
**Les différents post-traitements :**
- Travailler avec le sable : prendre l'objet, le mettre dans un bécher avec du sable, on tasse puis on met au four à 110°, le PLA va se ramollir un petit peu et permettre aux couches d'adhérer entre elles
- Travailler avec du solvant : s'évapore avec la chaleur (permet d'obtenir de la transparence si on a utilisé un filament transparent)
Note : **Le radeau** est la couche que l'on peut mettre en dessous de l'objet
##### **Pour la fois suivante**
1. Créer un objet dont ont met l'impression en pause puis on met un autre objet à l'intérieur avant de finir l'impression.
2. Faire un post traitement sur l'ancien object pour faire mieux tenir entre elles les couches.
##### **09 et 14 / 11 / 2023 - Recherches et impression 3D**
##### **Les méthodes de post-traitements**
- **Lissage avec du solvant :** certains matériaux d'impression 3D (ex: ABS), peuvent être lissés en utilisant des solvants comme l'acétone sur la surface de l'objet qui peut aider à fondre légèrement le plastique, créant ainsi une liaison plus forte entre les couches.
- **Polissage mécanique :** avec du papier de verre fin pour améliorer l'adhérence entre les couches et aider à éliminer les petites irrégularités de surface.
- **Vaporisateurs adhésifs :** certains sont conçus pour améliorer l'adhérence entre les couches et la surface du plateau d'impression, ils permettent d'aider à prévenir le décollement des bords pendant l'impression.
- **Application d'adhésif :** colles ou sprays d'adhérence utilisés sur le plateau d'impression pour une meilleure adhérence entre l'objet et la surface d'impression.
- **Chauffage du plateau d'impression :** peut améliorer l'adhérence en favorisant l'adhésion du matériau en fusion pendant l'impression (ex: l'ABS bénéficie particulièrement du chauffage du plateau).
- **Modification des paramètres d'impression :** des ajustements dans les paramètres d'impression (température d'extrusion, vitesse d'impression, résolution de la première couche) influencent l'adhérence entre les couches.
- **Utilisation de l'aide à la dissolution :** PVA (filament spécial, ex: alcool polyvinylique) est utilisé comme support soluble qui peut être dissous après l'impression pour laisser une surface plus lisse et favoriser une meilleure adhérence entre les couches.
\--> Les méthodes varient selon le matériau d'impression 3D et des spécificités de l'imprimante
##### **Impression 3D : objet avec arrêt d'impression**
##### **Test de ma sphère dans une sphère (Avec Sanjay, Ryan et Marya)**
En codant une simple sphère sur open scad, et en la vidant de son remplissage sur idea maker nous avons réussit a imprimer uniquement la coque de la sphère.
Ensuite, nous avons réimprimé la même sphère avec un PLA transparent en y plaçant notre première petite sphère dans le but de savoir si la technique était possible avec une sphère de taille plus importante mais aussi pour tester le PLA transparent.
##### **Code :**
$fn=1000; // Augmenter le nombre de faces pour une sphère plus lisse
d=5;
a=5;
H=0;
R=40;
N=90
difference() {
difference() {
sphere(r=R-a/2);
for (i=\[1:1:N\]) {
rotate(\[0,0,i\*360/N\]) translate(\[(R-a/2),0,H+a/2\])
cube(\[100,a-4,a\], center=true);
}
};
sphere(r=(R-a/2)-2);};
##### **Résultat final :**
Notre sphère est de 5cm de diamètre avec une sphère de 2cm de diamètre en jaune a l'intérieur.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-15-a-18-26-38.png)
Étant donné que le test de la sphère dans un sphère fût concluant, nous avons réitérer le test mais cette fois ci de manière plus complexe en y insérant des trous pour visualiser davantage l'objet a l'intérieur mais toujours avec un PLA transparent. Nous avons décidé d'imprimer cette sphère en 4 copies pour que chacun ait la sienne en y insérant l'object de notre choix.
J'ai choisi d'imprimer un bonhomme de neige bicolore : son chapeau en rouge et son corps en blanc.
##### **Visualisation sur idea maker :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-15-a-18-33-43.png)
Au moment de l'impression, pour libérer des imprimantes et optimiser le temps, j'ai décidé d'imprimer mon objet sur le même plateau que 2 autres personnes qui voulaient imprimer un objet à l'aide des mêmes bobines.
Cependant, l'impression a échoué car un des objet imprimé était trop peu stable et a donc perturbé l'impression de tous les objets du plateau. De ce fait, par manque de temps pour imprimer un nouvel objet, j'ai décidé de ne mettre que des grains de riz à l'intérieur de ma sphère.
##### **Processus d'impression :**
1\) Lancement de l'impression de la sphère de 5cm de diamètre
2\) Arrêt de l'impression lorsque 1/4 de la sphère s'est formée (slice - éditer - autre - entrer la hauteur du stop)
3\) Insertion des grains de riz dans le sphère
4\) Reprise et fin de l'impression de la sphère
##### **Résultat final :**
*Une sphère trouée transparente avec des grains de riz dedans.*
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-16-a-13-58-45.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-16-a-14-41-44.png)
##### **16 / 11 / 2023 - 3ème séance au FabLab**
##### **Retour sur l'impression 3D**
J'aurai pu améliorer l'impression de mon bonhomme de neige en l'imprimant seul sur le plateau en ajoutant plus de support pour optimiser l'impression.
Avec le groupe, nous aurions pu planifier l'arrêt d'impression directement dans les paramètres de Idea Maker au lieu de le faire manuellement sur l'imprimante.
**Raccourci :** Slice - Éditer - Autre - Entrer la hauteur du stop
##### **Introduction à l'Arduino**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-16-a-15-20-34.png)
##### **03 / 12 / 2023 - Apprentissage d'Arduino à la maison**
##### **Lien pour voir les LEDs s'allumer**
https://www.canva.com/design/DAF17lzBbMo/2mA7eiOW7RgZ\_L6\_-h8MbQ/edit?utm\_content=DAF17lzBbMo&utm\_campaign=designshare&utm\_medium=link2&utm\_source=sharebutton
##### **Installation d'Arduino**
J'ai emprunté un Starter Kit Arduino au FabLab afin d'apprendre à utiliser un Arduino seule, à la maison. J'ai tout d'abord télécharger l'application Arduino IDE 2.2.1-arm64 sur mon ordinateur pour pouvoir coder un programme me permettant de faire clignoter des LED intégrées Arduino.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-12/image.png)
##### **1) Faire clignoter une LED intégrée Arduino pendant 3 secondes**
##### **Code :**
void fonctionnement() {
pinMode(13, OUTPUT);
//du courant est envoyé sur la borne 13 donc la LED est alimentée et s'allume
}
void boucle() {
digitalWrite(13, HIGH);
delay(3000);
//la LED reste allumée pendant 3s
digitalWrite(13, LOW);
//absence de courant sur la pin 13
delay(3000);
//la LED reste éteinte pendant 3s
}
void fonctionnement() {
pinMode(13, OUTPUT);
pinMode(9, OUTPUT);
pinMode(7, OUTPUT);
}
void boucle() {
digitalWrite(13, HIGH);
digitalWrite(9, LOW);
digitalWrite(7, LOW);
delay(1000);
digitalWrite(13, LOW);
digitalWrite(9, HIGH);
digitalWrite(7, LOW);
delay(1000);
digitalWrite(13, LOW);
digitalWrite(9, LOW);
digitalWrite(7, HIGH);
delay(1000);
}
**Commentaires :** L'impression m'a pris 57min. Ne savant pas utiliser les différents bobines à disposition et ne savant pas encore paramétrer le logiciel d'impression **Ideamaker** mon micro à malheureusement qu'une seule et unique couleur.
**2. Réaliser un objet 3D de notre choix sur OpenSACD qui ne peut être obtenu uniquement via l'impression 3D.**
**Sorbonne Université** :
```sql
color ("DodgerBlue") rotate([0, 90, 0]) linear_extrude(height = 165, center = false, convexity = 10, twist = 4000, $fn = 100)
translate([2, 2.5, 0]) circle(r = 1);
color ("DarkTurquoise") linear_extrude(height=1) text ("SORBONNE UNIVERSITÉ", size = 10, valign = "centre", halign = "centre");
color ("DodgerBlue") rotate([0, 90, 0]) linear_extrude(height = 165, center = false, convexity = 10, twist = 4000, $fn = 100)
translate([2, 2.5, 0]) circle(r = 1);
color ("DarkBlue") rotate([0, 90, 0]) linear_extrude(height = 165, center = false, convexity = 10, twist = 4000, $fn = 100)
translate([-2,-2.5, 0]) circle(r = 1);
```
Je n'ai malheureusement pas réussi à l'imprimer en raison de problème lors de l'enregistrement de mon fichier sur **OpenSCAD** vers le ficher **SQL**. Dû à cette erreur de téléchargement que j'ai essayé de relancer plusieurs fois sans réussite, je n'ai pas la version imprimé de cet objet...
#####
##### Séance n°2 : Polyvalence des filaments et techniques d'impressions
**1. Introduction**
Les **imprimantes 3D** offrent une grande polyvalence avec une **variété de filaments et de techniques d'impression**, ce qui élargit considérablement les possibilités de création. Elles sont compatibles avec différents types de filaments, chacun ayant des **propriétés spécifiques**. De plus, ces imprimantes prennent en charge des techniques avancées telles que l'impression multi-matériaux, l'impression bi-color/multi-couleurs, l'impression en double extrusion, et l'impression avec des supports solubles. Ces fonctionnalités permettent aux utilisateurs d'explorer des designs plus complexes et diversifiés.
**2. Exemples de filaments**
**PLA :**
- Caractéristiques : Biodégradable, facile à imprimer, idéal pour le prototypage rapide. Avec aspect bois possible.
- Utilisations courantes : Projets non soumis à des contraintes de chaleur importantes.
**Fibres de carbone, de verre ou de métal :**
- Caractéristiques : Filaments renforcés, offrent une résistance et une rigidité supérieures.
- Utilisations courantes : Pièces structurelles, prototypes haute performance.
**PVA :**
- Caractéristiques : Soluble dans l'eau, utilisé comme support pour les impressions complexes.
- Utilisations courantes : Structures avec des surplombs, géométries complexes.
Autres exemples : TPU (souple caoutchouteux), possibilité de faire varier les propriétés élastique, filament transparent, résine
**3. Améliorer nos objets imprimés**
**Pour travailler avec 2 filaments différents :** dans **IdeaMaker**, on peut spécifier aux 2 extrudeurs de la machines (gauche et droite) si on utilise 2 matériaux différents, les valeurs changent. On peut garder le même code, le couper en 2 puis insérer un nouvel objet à créer et l'insérer à côté de l'ancien sur **IdeaMaker**.
**4. Les différents post-traitements**
- Travailler avec le sable : prendre l'objet, le mettre dans un bécher avec du sable, on tasse puis on met au four à 110°-120°, le PLA va se ramollir un petit peu et permettre aux couches d'adhérer entre elles. Cela va alors permettre de rendre l'objet plus adhésive, le durcir et renforcer la cohésion.
- Travailler avec des solvants : avec le fil métallique, mettre la pièce à l'intérieur d'un bêcher, le chauffer pour permettre l'évaporation du solvant (permet d'obtenir la brillance et la transparence de l’objet notamment si on a utilisé un filament transparent).
Note : **Le radeau** est la couche que l'on peut mettre en dessous de l'objet
##### **Exercice n°2**
1. Créer un objet un peu complexe et fonctionnel, dans IdeaMaker mettre l'impression en pause puis insérer un autre objet (comme une écroue, roulement en bille etc...) à l'intérieur puis reprendre l'impression. Si on veut mettre un objet solide il faut pas qu’il dépasse de la dernière couche -> à ras ou carrément à l'intérieur de la couche supérieur
2. Faire un post traitement sur l'ancien object pour faire mieux tenir entre elles les couches.
# Naima DIKA
**18/10/23**
Lors de la première séance de prototypage : nous avons été initié au prototypage à l'aide des logiciels de code en 3D openSCAD et ideaMAKER pour imprimer nos objets.
**27/10/2023**
Pour ma première impression 3D, j'ai décidé de réalisé une "Toupie cône" avec OpenScad en utilisant le code suivant :
```
$fn=100; // Réglage de la finesse de l'objet
module toupie(){
difference() {
rotate([0,0,0])
cylinder(h=10, r1=0, r2=5,
center=true);
translate([0,0,10])
rotate([0,0,45])
cube ([5,5,2], center=true);
for (i = [0:90:360])
{
rotate ([0,0, il)
translate([6,0,01)
cylinder(h=2, r=1,
center=true);
}
}
}
toupie();
```
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-2023-10-27-a-14-25-12.png)
Il s'agit d'une toupie cylindrique sous forme de cône avec une base circulaire. La rotation s'effectue via le pic du cône. J'avais fait le choix de conserver le support de mon impression 3D afin de favoriser la rotation de ma toupie.
**13/11/2023**
Pour cette seconde impression, j'ai réalisé un kiosque en 3D à l'aide des logiciels OpenScad et Idea Maker. L'objectif de cette impression était de réaliser un objet plus complexe. J'ai décidé de mêler deux couleurs différentes pour mon objet. Au bout d'une heure impression j'ai changé la bobine de fil d'impression 3D par une autre bobine de couleur différente.
Mon objet a le code openscad suivant :
```
echo(version=version());
module example_translate()
{
translate([0, 0, -120]) {
difference() {
cylinder(h = 50, r = 100);
translate([0, 0, 10]) cylinder(h = 50, r = 80);
translate([100, 0, 35]) cube(50, center = true);
}
for (i = [0:5]) {
echo(360*i/6, sin(360*i/6)*80, cos(360*i/6)*80);
translate([sin(360*i/6)*80, cos(360*i/6)*80, 0 ])
cylinder(h = 200, r=10);
}
translate([0, 0, 200])
cylinder(h = 80, r1 = 120, r2 = 0);
}
}
example_translate();
```
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/maison3dfablab.png)
Lorsque j'ai récupéré mon objet, le support de l'impression était très épais et englobé la totalité du kiosque ainsi que les piliers. Il m'a été très difficile de l'enlever. Pour la prochaine fois, il serait intéressant que j'essaie de régler paramètre différemment pour obtenir un support moins épais.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/D38whatsapp-image-2023-11-16-a-09-53-23-ae36af73.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/whatsapp-image-2023-11-16-a-09-53-23-34fb87f2.jpg)
# wissal haji
Pour faire clignoter une led on a travaillé en groupe.
ce code permet de clignoter une LED connectée au port 12 en boucle, on a configuré le port de la LED en mode sortie, ensuite On allume la LED ,
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-12/screenshot-2023-12-08-at-11-52-14.png)
Pour l'objet dans objet , j'ai programmé une créer une boule à l'intérieure une cage. la cage est fermé j'ai juste pris une capture d' écran pour montrer la boule à l'intérieure.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/screenshot-2023-11-16-at-14-27-51.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/screenshot-2023-11-16-at-14-27-16.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/screenshot-2023-11-16-at-14-28-05.png)
Pour objets épais j'ai essayer de créer un bonne homme
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/screenshot-2023-11-16-at-14-28-27.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/screenshot-2023-11-16-at-14-28-38.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/screenshot-2023-11-16-at-14-28-50.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/screenshot-2023-11-16-at-14-29-00.png)
jardin avec fleur
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/8ed23bbc-2824-4243-8665-ab7f2e46d885.JPG)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/screenshot-2023-10-27-at-14-32-33.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/screenshot-2023-10-27-at-17-01-00.png)
# EL HELOU Muriel
#### Prototypage
Premièrement, dans ce cours on a appris les notions suivantes :
- OpenSCAD :
OpenSCAD est un programme de modélisation 3D basé sur la programmation qui donne aux utilisateurs la possibilité de créer des objets tridimensionnels en écrivant du code plutôt que d'utiliser une interface graphique classique. Il se sert d'un vocabulaire particulier qui permet de définir des structures géométriques et d'effectuer des transformations complexes à partir de primitives simples. Il est possible d'exporter les modèles générés dans des formats qui sont compatibles avec l'impression 3D, comme le format STL. OpenSCAD est un logiciel gratuit et open source, ce qui implique qu'il est libre et modifiable en fonction des besoins de l'utilisateur.
- Ideamaker :
Raise3D a développé IdeaMaker, un logiciel de découpage 3D qui permet de créer automatiquement des structures de support afin de simplifier l'impression de modèles complexes, notamment ceux avec des parties en surplomb. Il offre des options avancées qui offrent une grande personnalisation pour les utilisateurs expérimentés. Ce programme est particulièrement pratique pour créer des fichiers pour l'impression 3D en transformant des modèles 3D en instructions suivies par l'imprimante afin de créer l'objet final. De plus, cela offre une amélioration de la qualité d'impression, une diminution de la consommation de matériaux et la possibilité de visualiser le modèle découpé avant l'impression afin de repérer et corriger d'éventuelles erreurs.
- Impression 3D :
Une imprimante en 3D est un dispositif qui permet de créer des objets en trois dimensions. Selon l'application et les caractéristiques de l'imprimante, ces imprimantes peuvent employer différents matériaux tels que des plastiques (par exemple le PLA), des céramiques ou des métaux. Elles permettent de fabriquer des prototypes rapidement et de concevoir des pièces aux formes complexes. Néanmoins, elles comportent également des contraintes, notamment en ce qui concerne la résolution et la précision.
#### Devoir à faire
On devait imprimer un objet en 3D en utilisant OpenSCAD et Ideamaker.
**Étape 1 :** Pour ce devoir, puisque c'était notre première fois d'utiliser ce logiciel, j'ai décidé de choisir un objet à imprimer qui ne soit pas trop complexe, afin d'obtenir un objet réel. De ce fait, j'ai choisi d'imprimer une maison avec une porte et un toit.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-09/1.PNG)
J'ai travaillé sur le code suivant pour obtenir ce premier brouillon de maison :
module maison() {
difference() {
cube(\[40, 30, 20\]);
translate(\[10, 0, 10\]) cube(\[5, 2, 5\]);
translate(\[25, 0, 10\]) cube(\[5, 2, 5\]);
translate(\[17.5, 0, 0\]) cube(\[5, 2, 10\]); hauteur = 10
}
}
module toit() {
{
translate(\[0, 0, 20\])
rotate(\[0, 0, 0\])
scale(\[1, 1, 0.7\])
hull() {
translate(\[0, 0, 0\]) cube(\[40, 30, 1\]);
translate(\[20, 15, 15\]) cube(\[0.01, 0.01, 15\]);
}
}
}
maison();
toit();
**Étape 2 :** Par la suite, j'ai dû modifier ce code pour ajuster les fenêtres et ajouter une cheminée.
module maison() {
difference() {
cube(\[40, 30, 20\]);
translate(\[10, 0, 10\]) cube(\[5, 2, 5\]);
translate(\[25, 0, 10\]) cube(\[5, 2, 5\]);
translate(\[17.5, 0, 0\]) cube(\[5, 2, 12\]);
}
}
module toit() {
{
translate(\[0, 0, 20\])
scale(\[1, 1, 0.7\])
hull() {
translate(\[0, 0, 0\]) cube(\[40, 30, 1\]);
translate(\[20, 15, 15\]) cube(\[0.01, 0.01, 15\]);
}
}
}
module cheminee() {
{
translate(\[30, 10, 25\])
union() {
cylinder(h = 8, r = 2);
translate(\[0, 0, 8\])
cylinder(h = 2, r1 = 2.5, r2 = 2);
}
}
}
module porte() {
{
translate(\[17.5, 0, 0\])
union() {
cube(\[5, 0.5, 12\]);
translate(\[4, 0.75, 6\]) sphere(r = 0.5);
}
}
}
maison();
toit();
cheminee();
porte();
**Étape 3 :** Après encore quelques modifications, j'ai réussi à obtenir une maison que j'ai imprimée en 3D au Fablab. L'impression a pris environ 12 heures.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-09/maison.PNG)
#### Les microcontrôleurs
**C'est quoi ?**
La programmation et le prototypage électronique sont accessibles à tous grâce à l'intégration de microcontrôleurs Arduino sur une puce. Ces microcontrôleurs Arduino proposent un moyen efficace et accessible de mettre en œuvre des idées pour les expérimentés ainsi que les débutants.
**Utilisation :**
Il suffit de relier l'Arduino à un ordinateur, de créer un code simple dans l'environnement de développement Arduino, puis de le téléverser sur le microcontrôleur. Ce logiciel a donc la capacité de réguler des éclairages, des moteurs, et bien d'autres encore.
**Language :**
- C/C++, mais qui a été simplifié afin de faciliter son apprentissage.
#### App Inventor
Cette application a été développée par le MIT. Elle offre la possibilité de concevoir et de développer des applications de manière visuelle. Les "blocs" de code de l'application sont convertis en code JavaScript. Au cours du test, un code QR est créé afin de visualiser l'application à l'aide de l'application "AI Companion". Toutefois, afin de proposer une application sur l'App Store (par exemple), il est indispensable d'avoir une licence Xcode.
# Maéva DORMANT
#### **Informations générales :**
- **UE :** MU4IN011, Processus d'innovation, M1 Management de l'innovation
- **Intervenant :** M. SIMON, Directeur du Fablab de Sorbonne Université
- **Étudiante :**
#### **Notes de cours :**
##### Cours n°1 : Introduction à .openscad
**1. Définition**
**OpenSCAD est un logiciel de modélisation 3D basé sur le texte** qui permet de créer des modèles 3D paramétriques en utilisant du code. Il est utilisé pour la personnalisation de pièces, la conception d'objets d'impression 3D, la réplication de pièces avec des variations et l'automatisation. C'est un outil utile dans l'éducation pour enseigner la modélisation 3D, la programmation et la géométrie.
**2. Première approche du logiciel**
```lua
d=5;
a=10;
H=50;
R=40;
N=10;
for (i=[1:1:N]) {
rotate([0,0,i*360/N]) translate([(R-a/2),0,H+a/2]) cube(a,center=true);
}
cylinder(h=H,r=R,center=true);
```
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/qSnimage.png)
##### Cours n°2 : Polyvalence des filaments et techniques d'impressions
**1. Introduction**
Les **imprimantes 3D offrent une polyvalence en matière de choix de filaments et de techniques d'impression**, permettant une vaste gamme de projets. Elles sont compatibles avec divers types de filaments. Chaque filament présente des propriétés spécifiques, offrant aux utilisateurs la flexibilité nécessaire pour choisir le matériau adapté à leurs besoins.
En outre, les imprimantes 3D sont compatibles avec des techniques avancées d'impression, telles que l'impression multi-matériaux et multi-couleurs, l'impression en double extrusion, ainsi que l'impression avec des supports solubles. Ces fonctionnalités élargissent considérablement les possibilités de création.
**2. Exemples de filaments**
**PLA :**
\- Caractéristiques : Biodégradable, facile à imprimer, idéal pour le prototypage rapide.
\- Utilisations courantes : Projets non soumis à des contraintes de chaleur importantes.
**Fibres de carbone, de verre ou de métal :**
\- Caractéristiques : Filaments renforcés, offrent une résistance et une rigidité supérieures.
\- Utilisations courantes : Pièces structurelles, prototypes haute performance.
**PVA :**
\- Caractéristiques : Soluble dans l'eau, utilisé comme support pour les impressions complexes.
\- Utilisations courantes : Structures avec des surplombs, géométries complexes.
##### Cours n°3 : Les micro-contrôleurs
**1. Introduction**
Les **micro-contrôleurs Arduino sont de petits ordinateurs sur une puce**, conçus pour rendre la programmation et le prototypage électronique accessibles à tous. Que l'on soit débutant ou confirmé, ils offrent un moyen puissant et abordable de donner vie à aux idées.
**2. Utilisation simplifiée**
Pour les utiliser, il suffit de **connecter l'Arduino à un ordinateur**, d'écrire un code simple dans l'environnement de développement Arduino, puis de téléverser ce code sur le micro-contrôleur. Le programme peut contrôler des lumières, des moteurs, des capteurs, etc.
**3. Langage accessible**
Le **langage de programmation Arduino est basé sur C/C++**, mais simplifié pour faciliter l'apprentissage. De nombreux exemples de code sont disponibles en ligne, ce qui facilite la création de projets amusants, éducatifs ou même pratiques.
##### Cours n°4 : Développement d'applications mobiles pour les non-informaticiens
**1. Un peu d'histoire**
Auparavant (avant 2007), les applications étaient natives en C++/C#. À la fin 2008, Apple et Android deviennent les 2 grands leaders du marché. À ces époques, les applications web étaient des **pages de texte statique** (HTML). Par la suite, le **web 2.0** (pages actives) entrent en vigueur (HTML, CSS, JS). Les frameworks Javascript sont : React JS, Vue JS et ANGULAR JS.
**2. App inventor**
C'est une seule application pour designer et développer créée par le MIT. Il permet de **transformer le code de l'application en "bloc" en code JS**. En phase de test, il génère un QR code et l'application "AI Companion" permet de la visualiser. Néanmoins, si l'on souhaite l'envoyer sur l'App store (par exemple), il faut une licence Xcode.
---
#### **Exercices :**
##### Exercices donnés lors du cours n°1 : Réalisation de l'objet de notre choix
**1. Réaliser un objet 3D sur .openscad utilisant la différence ou l'addition.**
Mon choix s'est porté sur la réalisation d'un bonhomme de neige. J'utilise la différence pour créer des sphères creuses.
- [x] Étape 1 : Code (Openscad)
```lua
$vpt=[4,2.5,38];
$vpr=[83,0,29];
$vpd=250;
// Boules
difference(){
translate([0,0,10])
color("#FFFFFF") sphere(20);
translate([-30,-30,-10])
color("#FFFFFF") cube([100,100,10]);
color("#FFFFFF") sphere(13);
}
difference(){
translate([0,0,40])
color("#FFFFFF") sphere(15);
translate([-30,-30,-10])
color("#FFFFFF") cube([100,100,10]);
color("#FFFFFF") sphere(13);
}
difference(){
translate([0,0,60])
color("#FFFFFF") sphere(10);
translate([-30,-30,-10])
color("#FFFFFF") cube([100,100,10]);
color("#FFFFFF") sphere(10);
}
// Bras
translate([-30,0,45])
rotate([0,100,0])
color("#582900") cylinder(20,2,2);
translate([10,0,42])
rotate([0,80,0])
color("#582900") cylinder(20,2,2);
// Nez
translate([0,-10,60])
rotate([90,0,0])
color("#ff8000") cylinder(5,2,1);
// Chapeau
translate([0,0,65])
color("#000000") cylinder(2,12.5,12.5);
translate([0,0,65])
color("#000000") cylinder(15,8,8);
```
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/wDyimage.png)
- [x] Étape 2 : Définition des paramètres d'impression (IdeaMaker)
Pour imprimer en 1 heure(s) 57 min 18 sec, un objet de 50.000 x 32.936 x 66.235 :
- Type de filament : PLA 1,75 mm
- Couche : Hauteur de couche - 0,2500 mm / Coques - 1,0
- Remplissage : Densité - 25% / Motif : Cubique
- Aide à l'adhérence : Radeau uniquement
- [x] Étape 3 : Impression (Raise3D)
Il suffit de lancer l'impression en respectant les paramètres d'impression.
**2. Réaliser un objet 3D sur .openscad. Il doit être uniquement réalisable via l'impression 3D.**
Mon choix s'est porté sur la réalisation d'un chat assis.
- [x] Étape 1 : Code (Openscad)
```lua
$fn=30;
// TÊTE
difference(){
color("#E5E4E2") hull(){
translate([0,0,15])
scale([1,0.75,1])
sphere(7);
}
}
// OREILLES
module oreilles(){
hull(){
translate([2,0,0])
sphere(1);
translate([-2,0,0])
sphere(1);
translate([0,2,0])
sphere(1);
}}
translate([5,0,20])
rotate([-90,100,0])
color("#808080") oreilles();
translate([-5,0,20])
rotate([-90,-100,0])
color("#808080") oreilles();
// CORPS
translate([0,1,1])
scale([1.8,1.5,1])
color("#E5E4E2") sphere(3);
translate([0,1,2])
rotate([4,0,0])
color("#808080") cylinder(7.5,4,1.5);
// QUEUE
module queue(){
hull(){
translate([0,.5,13])
sphere(0.5);
translate([0,4,18])
sphere(1);
}
}
translate([0,4,-12])
color("#E5E4E2") queue();
// BRAS
translate([-6,0,4.5])
rotate([0,75,0])
color("#808080") cylinder(5,1,1.5);
translate([6,0,4.5])
rotate([0,-75,0])
color("#808080") cylinder(5,1,1.5);
// MAINS
module mains(){
scale([2,2,1])
sphere(.8);
translate([0,-2,0])
scale([1,3,1])
sphere(.6);
translate([-1,-2,0])
rotate([0,0,-20])
scale([1,3,1])
sphere(.6);
translate([1.2,-1.5,0])
rotate([0,0,20])
scale([1,3,1])
sphere(.6);
translate([-2,-.5,0])
rotate([0,0,-60])
scale([1,3,1])
sphere(.6);
}
translate([5.6,0,5 ])
rotate([-90,0,80])
color("#E5E4E2") mains();
translate([-5.6,0,5 ])
rotate([-90,0,80])
color("#E5E4E2") mains();
// JAMBES
translate([-3,1,1])
rotate([-90,0,135])
color("#808080") cylinder(12,2,1.5);
translate([3,1,1])
rotate([-90,0,-135])
color("#808080") cylinder(12,2,1.5);
// PIEDS
module pieds() {
difference(){
scale([1,2,1])
sphere(2);
translate([-2,-10,-2])
cube([5,20,2]);
}
translate([0,-3,.80])
sphere(.8);
translate([-1,-3,.75])
sphere(.75);
translate([1,-3,.75])
sphere(.75);
}
translate([-11.5,-8,3])
rotate([-90,15,-50])
color("#E5E4E2") pieds();
translate([11.5,-8,3])
rotate([-90,-15,50])
color("#E5E4E2") pieds();
```
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-2023-10-27-a-22-05-48-1.png)
- [x] Étape 2 : Définition des paramètres d'impression (IdeaMaker)
Pour imprimer en 1 heure(s) 16 min 32 sec, un objet de 50.000 x 36.166 x 48.339 :
- Type de filament : PLA 1,75 mm
- Couche : Hauteur de couche - 0,2500 mm / Coques - 1,0
- Remplissage : Densité - 25% / Motif : Cubique
- Aide à l'adhérence : Radeau uniquement
- [x] Étape 3 : Impression (Raise3D)
Il suffit de lancer l'impression en respectant les paramètres d'impression.
##### Exercice donné lors du cours n°2 : Ajout de complexité
**1. Réaliser un objet plus complexe. Par exemple, mettre un objet solide dans une impression 3D ou réaliser une impression bi-colore.**
Mon choix s'est porté sur la réalisation d'une sphère creuse.
- [x] Étape 1 : Code (Openscad)
```lua
$fn = 100; // Nombre de faces pour l-approximation de la sphère
$r_ext = 20; // Rayon externe de la sphère
$r_int = 15; // Rayon interne de la sphère creuse
difference() {
sphere($r_ext);
translate([0, 0, 0])
sphere($r_int);
}
```
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/lusimage.png)
- [x] Étape 2 : Définition des paramètres d'impression (IdeaMaker)
Pour imprimer en 2 heure(s) 38 min 33 sec, un objet de 60.000 x 60.000 x 60.000 :
- Type de filament : PLA 1,75 mm (transparent)
- Couche : Hauteur de couche - 0,500 mm / Coques - 1,0
- Remplissage : Densité - 10% / Motif : Cubique
- Aide à l'adhérence : Radeau uniquement
⚠️ Lors de la définition de l'échelle, il faut veiller à ce que la sphère soit plus grande que l'objet à insérer.
- [x] Étape 3 : Impression (Raise3D)
Lors de l'impression, stopper l'impression à mi-hauteur (approximativement la moitié du temps d'impression) et insérer l'objet à l'intérieur de la sphère.
**2. Réaliser un post-traitement sur l'objet précédent : [https://www.youtube.com/watch?v=Jv-CbnB8Uz4&t=83s](https://www.youtube.com/watch?v=Jv-CbnB8Uz4&t=83s "Lien du tutoriel")**
- [ ] Réunir le matériel : Pièce imprimée avec du filament ABS - Boîte de conserve - Acétone
- [ ] Verser de l'acétone dans le récipient et le faire chauffer.
- [ ] Plonger la pièce dans la boîte et refermer.
##### Exercice donné lors du cours n°3 : Montage simple
**À l'aide du cours, réaliser un projet simple à l'aide des micro-contrôleurs Arduino.**
- [ ] Récupérer le cours.
- [x] Réaliser le code.
```c++
const int RED_LED_PIN = 0; // Broche pour la LED rouge
const int GREEN_LED_PIN = 1; // Broche pour la LED verte
void configurationInitiale() {
pinMode(RED_LED_PIN, OUTPUT); // Configuration de la broche pour la LED rouge en sortie
pinMode(GREEN_LED_PIN, OUTPUT); // Configuration de la broche pour la LED verte en sortie
}
void bouclePrincipale() {
digitalWrite(RED_LED_PIN, HIGH); // Allumer la LED rouge
digitalWrite(GREEN_LED_PIN, LOW); // Éteindre la LED verte
delay(2000); // 2 secondes d'attente
digitalWrite(RED_LED_PIN, LOW); // Éteindre la LED rouge
digitalWrite(GREEN_LED_PIN, HIGH); // Allumer la LED verte
delay(2000); // 2 secondes d'attente
}
void setup() {
configurationInitiale();
}
void loop() {
bouclePrincipale();
}
```
- [ ] Simuler le montage sur Thinkercad.
- [ ] Réaliser le vrai montage Arduino.
##### Exercice donné lors du cours n°4 : App inventor
**Mettre en place un premier programme, application et la tester sur notre téléphone.**
# Salma MOSTAGHAT
**18/10/23 :** Découverte d'OpenSCAD (commandes simples, boucles et union et différence) ainsi qu'IdeaMaker.
**26/10/23 : **Tentative d'impression en 3D d'une coque de téléphone, grâce à un code élaboré sur Openscad :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/152image.png)
Voici le résultat obtenu :
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/3f1image.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/228image.png)
Je suis moyennement satisfaite du résultat, en effet les traits supérieurs ne sont pas compacts ce qui fait que la surface supérieure est très fragile. De plus, l'inscription sur ma coque n'est pas sortie lors de l'impression.
**Pour la prochaine séance :**
Reflechir à imprimer avec d'autres couleurs, d'autres matières
**14/11/23 :** Conception d'un objet 3D plus complexe que le précédent.
Pour cet exercice, j'ai décidé de m'aventurer dans la modélisation d'un flocon de neige. Ce fut un challenge pour moi car je ne savais pas qu'on pouvait utiliser les fonctions sin et cos sur openSCAD. Voici mon programme :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/948image.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/VUbimage.png)
Par manque de temps, je n'ai pas pu l'imprimer au Fablab mais j'essaierai, la prochaine fois. Avec le trou que j'ai crée, je pourrai même le faire passer à travers un fil en guise de pendentif ou pour un bracelet.
# Louly NADJAR
**SÉANCE 1**
**Impression 3D d'une bobine pour fil**
Voici le code utilisé sur OpenSCAD :
**h = 20;**
**r = 5;**
**color("grey")**
**translate(\[0,0,10\])cylinder(h,r,r, center = true);**
**color("red")**
**for(i=\[1:1:12\]) {**
**rotate(\[0,0,i\*30\])translate(\[5,5,20\]) circle(5);**
**}**
**color("red")**
**for(i=\[1:1:12\]) {**
**rotate(\[0,0,i\*30\])translate(\[5,5,0\]) circle(5);**
**}**
Résultat souhaité :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-2023-10-27-a-16-18-30.png)
Résultat obtenu :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-2023-10-27-a-16-22-50.png)
Problèmes rencontrés :
- La plaque de haut de la bobine qui n'est pas présente. Elle était trop bien collée avec la machine et que c'était difficile à enlever.
- En bas du cylindre il y a eu un défaut mais je ne sais pas pour quelle raison.
**Impression 3D d'un objet impossible à réaliser autrement que par imprimante 3D**
Voici le code utilisé sur OpenSCAD :
**$fn = 100;**
**ray\_ext = 20;**
**ray\_cell = 2;**
**distance\_cell = 5;**
**translate(\[0,0,20\])**
**sphere(r=ray\_ext, $fn=$fn);**
**module nid\_ab(){**
**for (x = \[-ray\_ext : distance\_cell : ray\_ext\]){**
**for (y = \[-ray\_ext : distance\_cell : ray\_ext\]){**
**for (z = \[-ray\_ext : distance\_cell : ray\_ext\]){**
**translate(\[x,y,z\])**
**color("pink")sphere(r=ray\_cell, $fn = 6);**
**}**
**}**
**}**
**}**
**translate(\[0,0,20\])**
**nid\_ab();**
Voici le résultat souhaité :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-2023-10-27-a-16-28-02.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-2023-10-27-a-16-27-50.png)
Malheureusement, je n'ai pas eu le temps d'arriver jusqu'à impression.
\-----------------------------------------------------------------------------------------------------------------------------
**SÉANCE 2**
Dans le but de persévérer pour créer ma bobine, j'ai réaliser un code un peu modifié, avec des extrémités plus épaisses notamment. De plus, pour le complexifier un peu, j'aimerai arrêter l'impression au milieu pour changer de couleur de fil.
Voici le code utilisé :
**h = 30;**
**r = 5;**
**translate(\[0,0,15\])cylinder(h,r,r, center = true);**
**h2 = 5;**
**r2 = 10;**
**color("grey")**
**translate(\[0,0,30\])cylinder(h2,r2,r2, center = true);**
**h2 = 5;**
**r2 = 10;**
**color("grey")**
**translate(\[0,0,2.5\])cylinder(h2,r2,r2, center = true);**
Ainsi que le résultat souhaité :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-13-a-16-32-36.png)
# Lahiaoui Zineb
## **27/10/2023**
[1er objet réalisé sur OpenSCAD : rosace](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/img-0896.png)
Après une première séance d’initiation au codage 3D j’ai réalisé cette rosace avec le code ci-dessous.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/img-0896.png)
Avant l’impression j’ai rajouté des radeaux pour plus de stabilité pendant l’impression
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/img-0895.jpg)
Malheureusement mon objet s’est décollé du support pendant l’impression, sûrement parce qu’il était trop fin il y’a eu un problème de cohésion !
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/img-0895.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/img-0894.jpg)
De plus, non seulement il s’est décollé du support mais il aussi fondu
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/img-0892.jpg)
## **16/11/2023**
Pour la troisième séance on devait faire un objet dans un objet j’ai eu deux idées pour cette partie ;
La première faire un cube où je vais graver à l’intérieur un mot en l’occurrence ici j’ai rajouté le nom de mon projet PPE
j’ai d’abord essayer avec ce code j’ai eu beaucoup de mal à placé le mot dans le cube
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/img-0975.jpeg)
Mais après plusieurs tentatives j’ai réussi à y parvenir !
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/img-0974.jpeg)
Donc j’ai essayé de faire un autre objet complexe. C’est une fleur avec une boxe à l’intérieur.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/DMlimg-0970.jpeg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/img-0973.jpeg)
# Sana MEBARKIA
#### **18 / 10 / 2023 - 1ère séance au FabLab**
##### **Introduction au prototypage**
- Découverte du logiciel de code : openSCAD
- Découverte du logiciel d'impression 3D : ideaMaker
#### **25 / 10 / 2023 - 2e séance au FabLab**
OBJET COMPLEXE : PARAPLUIE
IMAGE PROTOTYPE :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-2023-10-27-a-16-31-13.png)
CODE:
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-2023-10-27-a-16-32-09.png)
PROTOTYPE IDEA MAKER :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-2023-10-27-a-16-25-04.png)
OBJET AVEC UNION ET DIFFERENCE : TABOURET
IMAGE PROTOTYPE :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-2023-10-27-a-16-33-20.png)
CODE :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-2023-10-27-a-16-33-26.png)
PROTOTYPE IDEA MAKER :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-2023-10-27-a-16-25-59.png)
RESULTAT À LA FIN DE L'IMPRESSION :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/img-140241f510c4-1.jpeg)
Malheureusement, la anse du parapluie était trop fine et donc trop fragile et elle s'est facilement cassé.
#### **15 / 11 / 2023 - 3e séance au FabLab**
Pour la conception d'un objet avec une pause durant l'impression, j'ai choisi de faire un support de téléphone bicolore. Je devrais donc mettre pause à l'impression au moment du changement de couleur.
IMAGE PROTOTYPE :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-15-a-11-13-36.png)
CODE :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-15-a-11-13-41.png)
#### **08 / 12 / 2023 - 4e séance au FabLab**
### **ARDUINO :**
Le but de cette partie est d’allumer une Led à l’aide d’un Bouton poussoir. La led s’allume seulement si le bouton a été appuyer.
La led est branchée sur la broche 2 et le bouton la broche 6 .On déclare deux variables qui prennent chacune la valeur d’une broches
```
int ledPin = 2;
int butPin = 6;
```
Elles seront utilisées ensuite pour les configurer en entrer ou en sortie
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-12/capture-decran-2023-12-08-a-13-40-46.png)
Ici la led est configurer en sortie et le bouton poussoir en entrer car celui-ci fournit une information logique
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-12/capture-decran-2023-12-08-a-13-41-33.png)
Deux lignes de code suffisent pour permettre à la led de s’allumer il n’est donc pas nécessaire d’écrire une fonction elles serons directement dans la fonction principal (loop).
Pour cela on déclare une variable val qui prendra la valeur du bouton poussoir en faisons une lecture si celui-ci est enfoncer il prendra elle prendra la valeur 1 sinon 0 cette valeur sera ensuite écrite dans le ledPin grâce au digitalWrite.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-12/capture-decran-2023-12-08-a-13-48-12.png)
BOUTON NON ENFONCÉ = LUMIERE ETEINTE
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-12/capture-decran-2023-12-08-a-13-48-20.png)
BOUTON ENFONCÉ = LUMIERE ALLUMÉ
# Bintou SIDIBE DRAME
***1ER OBJET (25/10/2023) : UNION ET DIFFERENCE***
**Code** :
```
union(){
intersection(){color ("white")cube(size=[8,8,8], center=true); color ("pink")sphere(r=4.50);}
}
difference() {
color("lightcyan")cube(size=[7,6,7], center=true); sphere(r=3.75);}
translate([0,0,6]) {
union() {
color ("pink")cylinder (h = 5, r=0.7, center = true, $fn=100);
rotate ([120,10,0])color("white")cylinder (h = 5, r=0.7, center = true, $fn=100);rotate ([60,10,0])color("white")cylinder (h = 5, r=0.7, center = true, $fn=100);
}
};
translate([0,0,6]) {
color ("lightcyan")sphere(r=1.60);
}
```
**Aperçu** :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/wGMimage.png)
***2EME OBJET (26/10/2023) : LE POUVOIR DE L'IMPRESSION 3D***
***Code*** ***:*
```
color ("peachpuff")linear_extrude(height = 8, center = true, convexity = 10, twist = -700, $fn=100)
translate([2, 0, 0])
circle(r = 1);
translate([2, 0, -4])
union() {
color("salmon")circle(6,$fn=100);
}
translate([1.2, -0.5, 6.60]) {
difference() {
color ("antiquewhite")sphere(r=3,$fn=100); rotate ([40,10,0])color ("antiquewhite")circle(10);
}
}
translate([1, -0.80, 7]) {
color ("peachpuff")cylinder (h = 4.2, r=0.70, center = true, $fn=100);
}
```
***Aperçu :***
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/pPNimage.png)
Je me suis rendue compte que le disque en rose est, contrairement à ce qu'on voit, un élément 2D donc pas imprimable. Il faudra le remplacer par un élément circulaire 3D.
**IMPRESSION 1ER OBJET (14/11/2023)**
- Filament PLA transparent
- Impression 3D en 1h50 (imprimante Donatello)
- Impression du support en une dizaine de minutes
- [](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/20231114-175254-min.jpg)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/20231114-180135-min.jpg)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/20231114-180621-min.jpg)
**Résultat (16/11/2023) :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/20231116-110119-min.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/20231116-110110-min.jpg)
J'aurais aimé que le résultat soit moins opaque, que l'on puisse voir à travers mais je suis tout de même satisfaite du résultat car c'est ma première impression. La forme et la taille sont celles que je souhaitais.
**1ER MONTAGE ARDUINO (05/12/2023)**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-12/mgPimage.png)
```
const int interrupteurPin = 7;
const int ledPin = 13;
void setup() {
pinMode(interrupteurPin, INPUT);
pinMode(ledPin, OUTPUT);
}
void loop() {
int etatInterrupteur = digitalRead(interrupteurPin);
if (etatInterrupteur == HIGH) {
digitalWrite(ledPin, HIGH); // Allume la LED
} else {
digitalWrite(ledPin, LOW); // Éteint la LED
}
}
```
===> Allumage d'un LED jaune en fonction de l'état d'un interrupteur à glissière
# HOURTZ Coralie
**25 octobre 2023**
**1ère Séance au FabLab sur le thème du prototypage, prise en main du logiciel de modélisation 3D OpenSCAD pour l'impression.**
A la suite de cette première séance, j'ai dû utiliser ce logiciel pour modéliser en 3D un objet qui ne peut-être imprimé qu'à l'aide de l'imprimante 3D.
Mon idée était de créer un tube dans lequel se déplacerait une boule sans jamais en sortir. J'ai donc commencé par la modélisation du tube creux fermé au deux extrémités.
Premier problème rencontré : ma ne peut être synthétisée dans les airs, il faut donc qu'elle puisse reposer sur une surface lors de l'impression. Je l'ai donc codée pour qu'elle s'imprime à la base du tuyau.
Cependant, avec une extrémité fermée, elle va s'imprimer sur la base et ne bougera donc plus a l'intérieur de mon tube. Face à ce deuxième problème, j'ai décidé de créer un trou dans la base du tube, dont le diamètre serait inférieur au diamètre de ma boule afin que celle-ci repose sur le support mais qu'elle ne puisse tout de même pas sortir de mon tube.
Voici à quoi ressemble la modélisation 3D :
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/2A6image.png) [](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/pPar1himage.png)
Voici à quoi ressemble le codage de cette pièce :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/gjGimage.png)
La photo du résultat de l'impression est à venir...
# Victoria MISSAMOU
#### **MU4MN011-Prototypage**
#### **Séance n°1**
**Exercice 1 :** Réaliser un objet original
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/RoWimage.png)
```
color("black")translate([40, 5, 43]) sphere(r=5);
color("white")translate([30, 5, 43]) sphere(r=5);
color("white")translate([40, -3, 43]) sphere(r=5);
color("purple")translate([30, -3, 43]) sphere(r=5);
color("purple")translate([40, 6, 50]) sphere(r=5);
color("black")translate([30, 6, 50]) sphere(r=5);
color("black")translate([40, -6, 50]) sphere(r=5);
color("white")translate([30, -6, 50]) sphere(r=5);
color("purple")translate([47,5,43]) sphere(r=5);
color("white")translate([47,1,43]) sphere(r=5);
color("blue")translate([47,5,50]) sphere(r=5);
color("black")translate([47,-1,50]) sphere(r=5);
color("purple")translate([54,5,43]) sphere(r=5);
color("purple")translate([60,5,43]) sphere(r=5);
color("black")translate([68,5,40]) sphere(r=5);
color("black")translate([75,5,35]) sphere(r=5);
color("blue")translate([85,5,27]) sphere(r=5);
color("purple")translate([35,1,53]) sphere(r=5);
color("purple")translate([0,0,42])rotate([90, 0, 0])
scale([10, 10, 10]) difference() circle(2);
color("white")translate([0,-15,42])rotate([90, 45, 60])
scale([10, 10, 10]) difference() circle(2);
color("white")translate([0,15,42])rotate([90, 45, -60])
scale([10, 10, 10]) difference() circle(2);
color("pink")polyhedron
(points = [
[0, -10, 40], [0, 10, 40], [0, 10, 0], [0, -10, 0], [40, -10, 40], [60, 10, 40],
[10, -10, 50], [10, 10, 50], [10, 10, 30], [10, -10, 30], [30, -10, 50], [30, 10, 50] ],
faces = [
[0,2,3], [0,1,2], [0,4,5], [0,5,1], [5,4,2], [2,4,3],
[6,8,9], [6,7,8], [6,10,11], [6,11,7], [10,8,11],
[10,9,8], [0,3,9], [9,0,6], [10,6, 0], [0,4,10],
[3,9,10], [3,10,4], [1,7,11], [1,11,5], [1,7,8],
[1,8,2], [2,8,11], [2,11,5] ]);
```
**Remarque** : Je pense que j'aurai du créer une boucle pour la création des minis boules. Le code est assez long et pas agréable à lire.
**Exercice 2 : Coder un objet uniquement réalisable en impression 3D**
J'ai voulu réaliser un dodécaèdre. Je ne suis pas sure que cela soit réalisable uniquement en 3D.
J'ai mis la boule dans une demi-sphère supporter par un cylindre
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/aZcimage.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/w5Jimage.png)
**Remarque** : je me suis inspirée de la flamme olympique
```
// Résolution
$fn=50;
translate (v=[0,0,12]) {
difference() {
difference() {
// Sphère externe
color("blue")sphere(r=10, $fn=50);
translate(v=[0,0,2]) {
//Sphère interne
sphere(r=8, $fn=50);
}
}
translate(v=[0,0,5]) {
// Cube servant à couper
cube(size = [20,20,10], center = true);
}
}
color("blue")translate(v=[0,0,-10]) {
cylinder (h=4, r1=5, r2=6, center = true);
}
}
module dodecahedron(height)
{
scale([height,height,height]) //paramètre de taille
{
intersection(){
//faire un cube
cube([5,5,4], center = true);
intersection_for(i=[0:4]) //loop i from 0 to 4, and intersect results
{
rotate([0,0,72*i])
rotate([116.565,0,0])
cube([5,5,4], center = true);
}
}
}
}
color("purple")translate([0,0,18])dodecahedron(4);
```
**Les prochaines étapes**
- Définition des paramètres d'impression sur IdeaMaker
- Impression par Raise 3D : travailler et approfondir la précision et la diversité de l'impression.
#### **Séance n°2**
**Exercice : mettre un objet solide dans une impression 3D ou réaliser une impression bi-colore.**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/5onimage.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/ckeimage.png)
```
color("pink")resize([20,8,20])translate([0,0,25])sphere(r=20);
for (i=[0:12]){
angle = i*360/12;
x = 20*cos(angle);
y = 20*sin(angle);
translate([x,y,0])
cylinder(h=2*20,r=5,$fn=100);}
cylinder(h=2,r=20,$fn=100);
translate([0,0,38])cylinder(h=2,r=20,$fn=100);
```
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/h1Timage.png)
- Type de filament : PLA 1,75 mm (transparent)
#### Séance n°3
Utilisation de l'arduino
```c++
// C++ code
//
void setup()
{
pinMode(LED_BUILTIN, OUTPUT);
}
void loop()
{
digitalWrite(LED_BUILTIN, HIGH);
delay(1000); // Wait for 1000 millisecond(s)
digitalWrite(LED_BUILTIN, LOW);
delay(1000); // Wait for 1000 millisecond(s)
}
```
J'ai réalisé le clignotement d'une LED via l'application TinkerCAD
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-12/VFnimage.png)
# Yasemin SOGUTLU
#### **PROTOTYPAGE**
##### ***Open SCAD***
OpenSCAD est un logiciel de modélisation 3D basé sur un script qui permet aux utilisateurs de créer des modèles 3D en écrivant du code, plutôt qu'en utilisant une interface graphique interactive. Logiciel utilise un langage propre pour créer des modèles 3D. Ce langage permet de définir des formes géométriques, d'appliquer des transformations complexes à partir de primitives simples. Les modèles créés avec Open SCAD peuvent être exportés dans des formats de fichiers standard pour l'impression 3D tel que STL. C'est un logiciel libre et open source ce qui signifie qu'il est gratuit à télécharger, à utiliser et à modifier.
##### ***Idea Maker***
Idea Maker es un logiciel de découpe 3D développé par Raise 3D qui peut générer automatiquement des structures de support. Le logiciel peut créer des supports nécessaires pour les parties en surplomb du modèle qui facilite ainsi l'impression de designs complexes. . Ils offrent des paramètres définis qui fournissent une personnalisation illimitée pour les utilisateurs avancés. C'est un logiciel idéal et utile pour préparer des fichiers pour l'impression 3D. Il convertit les fichiers de modèles 3D en instructions que l'imprimante 3D peut suivre pour créer l'objet physique. Il permet aux utilisateurs d'optimiser la qualité d'impression et d'économiser des matériaux. Il permet aussi aux utilisateurs de prévisualiser le modèle tranché avant l'impression ce qui peut aider à identifier et à corriger les problèmes éventuels.
##### ***Impression 3D***
Une imprimante 3D est un dispositif qui permet de créer des objets tridimensionnels. Les imprimantes 3D peuvent utiliser une variété de matériaux, y compris des plastiques comme le PLA, des céramiques, des métaux et plus encore. Le choix du matériau dépend de l'imprimante et de l'application spécifique. Elle permet la production rapide de prototypes et la fabrication de pièces complexes. Cependant, elle peut présenter des inconvénients comme une résolution et une précision inférieures.
#### **SÉANCE 1**
**POT VÉGÉTAL **
**Code:**
// Paramètres
pot\_diameter = 100;
pot\_height = 100;
wall\_thickness = 15;
drain\_hole\_diameter = 5;
num\_drain\_holes = 4;
// Module pour créer des trous de drainage
module drain\_holes() {
for(i = \[0:num\_drain\_holes-1\]) {
angle = i \* 360/num\_drain\_holes;
x = (pot\_diameter/2 - wall\_thickness) \* cos(angle);
y = (pot\_diameter/2 - wall\_thickness) \* sin(angle);
translate(\[x, y, 0\])
cylinder(r=drain\_hole\_diameter/2, h=wall\_thickness+1);
}
}
// Création du pot
difference() {
// Extérieur du pot
cylinder(r=pot\_diameter/2, h=pot\_height);
// Intérieur du pot
translate(\[0, 0, wall\_thickness\])
cylinder(r=(pot\_diameter/2 - wall\_thickness), h=pot\_height);
// Trous de drainage
drain\_holes();
}
**Photo OpenSCAD:**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/pot.png)
**Photo IdeaMaker:**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/Wb0capture-decran-2023-11-16-a-11-20-52.png)
**Impression 3D**: NON
**OBJET COMPLEXE:**
**Code:**
// Dimensions
height = 100; // Hauteur du prisme
radius = 50; // Rayon de l'hexagone
sphere\_radius = 10; // Rayon des sphères
// Création du prisme hexagonal
cylinder(h=height, r1=radius, r2=radius, $fn=6);
// Fonction pour ajouter une sphère à un sommet du prisme
module add\_sphere(angle, height) {
x = radius \* cos(angle);
y = radius \* sin(angle);
translate(\[x, y, height\])
sphere(r=sphere\_radius);
}
// Ajout des sphères aux sommets du prisme
for(i = \[0:5\]) {
angle = i \* 360/6;
add\_sphere(angle, 0); // Sphères à la base du prisme
add\_sphere(angle, height); // Sphères au sommet du prisme
}
**Photo Open SCAD:**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/complexe.png)
**Photo IdeaMaker:**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-16-a-11-24-13.png)
**Impression 3D:** OUI
**Photo de l'objet imprimé:**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/MI7image.jpeg)
**Durée de l'impression** : 1 heure
#### **SÉANCE 2**
**UNE CUBE ROUGE (avec un objet à l'intérieur):**
Pour la première session, j'avais créé un objet de couleur blanche. Pour la deuxième session, j'ai voulu expérimenter avec une couleur différente en utilisant la couleur rouge. En même temps, avant de démarrer la machine, j'ai appris comment changer la bobine lorsque je souhaite utiliser un autre matériel ou une couleur différente. J'ai lancé l'impression 3D, et la machine a commencé à créer l'objet. Lorsque j'en étais à la moitié de l'objet, j'ai arrêté la machine et j'ai placé à l'intérieur un petit objet. Puis la machine a continué à créer l'objet.
**Code :**
// Module pour créer un cube
module monCube(cote) {
cube(\[cote, cote, cote\]);
}
// Paramètres du cube
cote = 30; // Longueur du côté du cube
// Utilisation du module pour créer le cube
monCube(cote);
**Photo Open SCAD :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-16-a-11-16-43.png)
**Photo Idea Maker :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-16-a-11-12-11.png)
**Impression 3D**: OUI
**Photo de l'objet imprimé :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/img-5599.jpg)
**Durée de l'impression :** 55 minutes
# Qiancheng JIANG
### **1. PROTOTYPE 3D - CUBE HIGH 5**
**Au debut je voulais faire une balle avec le logo de High 5 dessus, après je me suis rendu compte que c'est très dur de le faire avec Openscad. Du coup j'ai pensé à le faire sur un cube.**
**Code：**
echo(version=version());
font = "Liberation Sans";
cube\_size = 40;
letter\_size = 30;
letter\_height = 5;
o = cube\_size / 2 - letter\_height / 2;
module letter(l) {
linear\_extrude(height = letter\_height) {
text(l, size = letter\_size, font = font, halign = "center", valign = "center", $fn = 16);
}
}
difference() {
union() {
color("green") cube(cube\_size, center = true);
translate(\[0, -o, 0\]) rotate(\[90, 0, 0\]) letter("H");
translate(\[o, 0, 0\]) rotate(\[90, 0, 90\]) letter("I");
translate(\[0, o, 0\]) rotate(\[90, 0, 180\]) letter("G");
translate(\[-o, 0, 0\]) rotate(\[90, 0, -90\]) letter("H");
}
translate(\[0, 0, o\]) letter("\\u263B");
translate(\[0, 0, -o - letter\_height\]) letter("5");
}
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-2023-10-27-a-16-38-48.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-2023-10-27-a-16-38-38.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/pvgcapture-decran-2023-10-27-a-16-39-12.png)
Malheureusement j'ai mis le 5 en inverse sur la face vers le bas.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/capture-decran-2023-10-27-a-21-34-07.png)
### **PHOTO EN REEL:**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/img-6027.JPG)
### **1. PROTOTYPE 3D - Car**
**Pour le deuxième produit, Je vais essayer de faire quelque chose d'un peu plus difficile, comme une petite voiture.**
**Code：**
cube(\[60,20,10\],center=true);
translate(\[5,0,10 - 0.001\])
cube(\[30,20,10\],center=true);
translate(\[-20,-15,0\])
rotate(\[90,0,0\])
cylinder(h=3,r=8,center=true);
translate(\[-20,15,0\])
rotate(\[90,0,0\])
cylinder(h=3,r=8,center=true);
translate(\[20,-15,0\])
rotate(\[90,0,0\])
cylinder(h=3,r=8,center=true);
translate(\[20,15,0\])
rotate(\[90,0,0\])
cylinder(h=3,r=8,center=true);
translate(\[-20,0,0\])
rotate(\[90,0,0\])
cylinder(h=30,r=2,center=true);
translate(\[20,0,0\])
rotate(\[90,0,0\])
cylinder(h=30,r=2,center=true);
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-16-a-11-39-26.png)
**Malheureusement, c'est parce que le matériau ne cessait d'obstruer l'ouverture de la buse au démarrage de l'imprimante 3D, de sorte que les deux roues situées de l'autre côté de la voiture n'étaient qu'à mi-hauteur. Et je n'ai pas cherché la bonne occasion pour mettre l'un des autres objets dans la voiture. (Je ne sais pas pourquoi je ne peux pas transférer les photos).**
**La prochaine fois, il devrait être possible d'imprimer les roues séparément et de fabriquer un mécanisme permettant à la voiture de se déplacer, puis de fabriquer un toit convertible pour la voiture afin de pouvoir ajouter d'autres objets à l'intérieur.**
# Fatmagul OZGUL : Les péripéties d'un apprenti sculpteur 3D
Pour m'initier à la programmation avec OpenSCAD, j'ai créé un objet qui reprend les concepts abordés lors du premier cours. Il s'agit d'un dispositif conçu pour vous aider à prendre des décisions lorsque vous vous trouvez dans une situation où vous ne savez pas quoi faire. Il vous suffit de faire tourner l'objet, et la face qui est face à vous détermine votre choix, en suivant le code couleur : le vert signifie "oui" et le rouge signifie "non". Ainsi, vous pouvez attribuer le résultat à la destinée si les choses ne se déroulent pas comme prévu.
P.S. : Cet objet n'a pas été imprimé en raison de préoccupations éthiques.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/objet-oui-non-photo.png)
Ensuite, j'ai décidé de créer un objet arborant le symbole de la Sorbonne Université. En effet, pendant mes trois années passées à cette université, je n'ai jamais eu l'occasion d'obtenir un objet portant le fameux logo de la Sorbonne Université, malgré ma participation à toutes les journées portes ouvertes et à l'écoute attentive de la promotion de leurs associations. J'ai donc décidé de prendre les choses en main et de créer moi-même un objet avec le symbole de la SU. Lors du processus de codage de cet objet, j'ai rencontré plusieurs problèmes : j'ai passé des heures à le coder sur OpenSCAD pour réaliser à la fin que tout le code était en 2D, donc non imprimable. Comme vous pouvez l'imaginer, cela m'a profondément déçu. Plutôt que de chercher des moyens pour le rendre en 3D, j'ai décidé de recommencer depuis le début en utilisant des fonction 3D. Cependant, il était extrêmement compliqué de trouver un moyen d'écrire 'Sorbonne Université' sur l'objet. Je commençait à perdre l'espoir (j'ai même sollicité ChatGPT, mais ses codes semblaient transformer les objets sur OpenSCAD en quelque chose de plus proche d'une possession démoniaque que d'une modélisation 3D). Finalement, j'ai découvert la fonction 'linear\_extrude', que j'ai surnommé affectueusement 'mon\_héros'. Grâce à cette fonction, j'ai pu convertir mon travail précédent en 2D en une version 3D.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/su-wiki.png)
Même avec cette magnifique modélisation, mon objet a lamentablement échoué lors de son impression en 3D. En fait, je n'ai pas su ajuster correctement des paramètres cruciaux tels que la densité de remplissage et le support. J'ai également considérablement réduit la taille de mon objet (3 cm) car je ne voulais pas attendre des heures pour voir le résultat. Cependant, cette décision a abouti à un objet tellement petit et fragile que les supports étaient impossibles à enlever. La déception était à la hauteur de mon ambition...
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/U9R20231026-173619.jpg)
Cependant, je n'ai pas baissé les bras. J'ai décidé d'investir encore plus de plastique et d'énergie pour atteindre mon objectif ultime. En augmentant l'échelle à 7 cm et en ajustant les paramètres de densité (30% de remplissage, 1% de support), j'ai finalement réussi à obtenir l'objet tant désiré après une impression de 5 heures et 49 minutes:
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/20231027-152128.jpg)
J'ai dû me livrer à une bataille d'une heure avec cette petite merveille pour retirer les supports à l'intérieur et autour sans briser les lettres "SU" que j'avais soigneusement intégrées. Ça a été un véritable défi...
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-10/20231027-175930-1.jpg)
Le résultat final a pleinement justifié toutes les difficultés et souffrances endurées tout au long du processus. Maintenant que je sais qu'il existe des matériaux permettant d'avoir des supports solubles dans l'eau, je n'aurai plus à me casser la tête (ou les doigts) lors de mes prochains projets. Comme on dit, à cœur vaillant, rien d'impossible :)
# Maélanne Revol
## **Prototypage :**
#### **Séance 1 - FabLab : 18/10/2023**
##### **Introduction au prototypage** :
- Initiation à l’utilisation du logiciel OpenScad (codage)
- Découverte du logiciel IdeaMaker (impression 3D)
##### **Travail à faire pour la session suivante** :
1\) imprimer un objet en 3D qui implique des opérations simples sur OpenScad,
2\) imprimer ou coder pour un objet impossible ou très difficilement réalisable autrement que par impression 3D.
#### **Impression 3D : 18/10/2023**
##### **1) Impression d’un objet simple**
Pour cette exercice, j’ai choisi d’imprimer un rond de serviette. En effet, il s’agit d’un objet du quotidien et ayant une forme simple que nous avions abordé en séance de découverte du logiciel OpenScad. J’ai alors codé l’objet sur OpenScad et je me suis ensuite servie de IdeaMaker afin de l’imprimer au FabLab. Concernant les dimensions de mon objet, j’ai choisi des mesures qui me paraissaient cohérentes avec celles d’un objet utilisable au quotidien.
Code sur OpenScad :
// Définition des dimensions
diametre\_exterieur = 50; // Diamètre extérieur en mm
diametre\_interieur = 40; // Diamètre intérieur en mm
epaisseur\_anneau = 23; // Épaisseur de l'anneau en mm
// Création de l'anneau
difference() {
// Anneau extérieur
cylinder(d=diametre\_exterieur, h=epaisseur\_anneau);
// J'enlève l'intérieur pour créer un anneau vide
translate(\[0, 0, -1\]) // J'ajuste pour éviter des problèmes de rendu
cylinder(d=diametre\_interieur, h=epaisseur\_anneau + 2); // +2 pour m'assurer que l'intérieur est complètement retiré
}
Aperçu visuel :
COLLER LE STL OU CAPTURE OPENSCAD
##### **1) Impression d’un objet impossible ou difficilement réalisable autrement que par impression 3D**
Pour ce faire, j’ai eu une discussion avec une connaissance passionnée d’impression 3D. Cette personne m’a parlé de semelles de baskets à l’image de certaines existantes de la marque Nike. Alors, cette connaissance m’a aidé à imaginer le code suivant :
// Paramètres de la semelle
hauteur\_semelle = 10;
epaisseur\_semelle = 5;
taille\_semelle = 30;
// Fonction pour créer la semelle
module semelle() {
difference() {
// Création de la semelle
cube(\[taille\_semelle, taille\_semelle, hauteur\_semelle\]);
// Enlèvement du matériau pour créer la forme de la semelle
translate(\[taille\_semelle/4, taille\_semelle/4, 0\])
cylinder(h=hauteur\_semelle, r1=0, r2=taille\_semelle/2, $fn=100);
translate(\[3\*taille\_semelle/4, taille\_semelle/4, 0\])
cylinder(h=hauteur\_semelle, r1=0, r2=taille\_semelle/2, $fn=100);
translate(\[taille\_semelle/4, 3\*taille\_semelle/4, 0\])
cylinder(h=hauteur\_semelle, r1=0, r2=taille\_semelle/2, $fn=100);
translate(\[3\*taille\_semelle/4, 3\*taille\_semelle/4, 0\])
cylinder(h=hauteur\_semelle, r1=0, r2=taille\_semelle/2, $fn=100);
}
}
// Afficher la semelle
semelle();
Aperçu visuel :
COLLER STL
#### **Séance 2 - FabLab : 27/10/2023**
##### **Améliorer nos impressions 3D :**
**Pour travailler avec 2 filaments différents :** dans ideaMaker, on peut spécifier aux 2 extrudeurs de la machines (gauche et droite) si on utilise 2 matériaux différents, les valeurs changent. On peut garder le même code, le couper en 2 puis insérer le nouvel objet à créer et l'insérer à côté de l'ancien sur ideaMaker.
##### **Méthodes de post-traitement :**
- Travailler avec le sable : prendre l'objet, le mettre dans un bécher avec du sable, on tasse puis on met au four à 110°, le PLA va se ramollir un petit peu et permettre aux couches d'adhérer entre elles
- Travailler avec du solvant : s'évapore avec la chaleur (permet d'obtenir de la transparence si on a utilisé un filament transparent)
NB : **Le radeau** est la couche que l'on peut mettre en dessous de l'objet
**Autres post-traitements pour faire plus adhérer les couches entre elles :**
1. **Chaleur contrôlée :**
- Pour certains thermoplastiques comme le PLA, l'utilisation d'une source de chaleur contrôlée après l'impression peut aider à fusionner légèrement les couches, améliorant ainsi l'adhérence.
2. **Vernis ou laque acrylique :**
- Appliquez une fine couche de vernis ou de laque acrylique sur la surface de la pièce. Cela peut contribuer à renforcer les couches en créant une couche externe plus solide.
3. **Ponçage et polissage :**
- Utilisez du papier de verre fin ou des tampons de polissage pour lisser la surface de la pièce. Cela peut éliminer les petites irrégularités entre les couches et favoriser une meilleure adhérence.
##### **Travail à faire pour la session suivante** :
1\) Créer un objet dont ont met l'impression en pause puis on met un autre objet à l'intérieur avant de finir l'impression.
2\) Faire un post traitement sur notre dernier object pour mieux faire tenir les couches entre elles.
#### **Imression 3D : 13/11/2023**
##### **1) Impression d’un objet contenant d’autres objets solides non imprimés **
Pour réaliser un contenant en 3D, j’ai choisi de réaliser une boite avec une particularité esthétique, dans laquelle je placerai des bonbons (mes objets solides non imprimés).
Code sur OpenScad :
// Création de la boîte
length=60;
linear\_extrude(height = 3, center = false)
difference() {
square(\[length,40\],center);
for ( i = \[1 : (length / 3)\] ){
translate(\[i\*3,4,0\]) {
square(\[1,32\]);
}
}
}
cube(\[length,1,15\]);
translate(\[0,40,0\]) {
cube(\[length,1,15\]);
}
cube(\[1,40,15\]);
translate(\[length-1,0,0\]) {
cube(\[1,40,15\]);
}
module prism(l, w, h){
polyhedron(
points=\[\[0,0,0\], \[l,0,0\], \[l,w,0\], \[0,w,0\], \[0,w,h\], \[l,w,h\]\],
faces=\[\[0,1,2,3\],\[5,4,3,2\],\[0,4,5,1\],\[0,3,4\],\[5,2,1\]\] );
}
Aperçu visuel :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/img-8676.jpeg)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/img-8679.jpeg)
##### **1) Post-traitement : améliorer l’adhérence des couches entre elles**
Pour augmenter l’adhérence entre elles des couches de ma boite à bonbons, pour des raisons de praticité, j’ai décidé d’utiliser le post-traitement qui consiste à l’utilisation d’une source de chaleur contrôlé, en me servant d’un four. Je peux me permettre d’utiliser cette méthode puisque ma pièce est petite. Par contre, elle nécessite une surveillance constante afin d’éviter la surchauffe. Étant donné les aspérités que l’on peut remarquer visuellement tant sur la partie orange que sur le reste du radeau (partie blanche), et la difficulté à décoller le radeau, je vais procéder à un ponçage d’abord grâce à une ponceuse à bandes, puis grâce à du papier de verre fin.
# BEN ABOUBOU Omayma
**18/10/2023**
Première séance prototypage et initiation avec d'un logiciel de code en 3D openSCAD et ideaMAKER pour imprimer nos objets
**26/10/2023**
Voici les deux objets que j'ai imprimé en 3D
**1er objet:**
J'ai souhaité créer un objet 3D en forme de verre en utilisant OpenSCAD
Dans ce script OpenSCAD :
- hauteur verre définit la hauteur totale du verre.
- diametre\_haut et diametre\_bas définissent les diamètres du haut et du bas du verre, respectivement.
- epaisseur\_paroi spécifie l'épaisseur des parois du verre.
La fonction cylindre crée un cylindre, et la fonction difference() est utilisée pour soustraire le cylindre intérieur (la paroi) du cylindre extérieur, formant ainsi la structure creuse d'un verre.
// Paramètres du verre
hauteur\_verre = 100;
diametre\_haut = 50;
diametre\_bas = 30;
epaisseur\_paroi = 5;
// Création du verre
difference() {
// Verre extérieur
cylinder(h=hauteur\_verre, d=diametre\_haut, $fn=100);
// Creuser le verre pour former la paroi
translate(\[0, 0, epaisseur\_paroi\])
cylinder(h=hauteur\_verre + epaisseur\_paroi, d=diametre\_bas, $fn=100);
}
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-13-231216.png)
**2ème objet:**
Dans ce deuxième objet, j'ai souhaité créer une forme composée de deux formes qui sont collées ensemble, je les ai positionnées de manière à ce qu'elles se chevauchent ou se touchent, puis les combiner en une seule forme en utilisant l'opération d'union. Voici un exemple de code qui combine un cube et une sphère pour former une forme composite :
// Crée un cube
cube(\[20, 20, 20\]);
// Crée une sphère
translate(\[10, 10, 10\])
sphere(15);
// Commente la création du cylindre pour le supprimer
/\*
translate(\[30, 30, 10\])
cylinder(h = 20, r1 = 0, r2 = 10);
\*/
// Combine les deux formes restantes en une seule forme composite
union() {
cube(\[20, 20, 20\]);
translate(\[10, 10, 10\])
sphere(15);
}
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/a7bimage.png)
**Impression 3d:**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/A4Himage.png)
**3ème objet**
**J'ai essayé de créer une raquette de Ping Pong , comme première étape, j'ai créé la tête de la raquette avec ce code :**
// Paramètres de la tête de la raquette
longueur\_tete = 150; // Longueur de la tête de la raquette
largeur\_tete = 70; // Largeur de la tête de la raquette
epaisseur\_tete = 10; // Épaisseur de la tête de la raquette
// Création de la tête de la raquette
translate(\[longueur\_tete / 2, largeur\_tete / 2, epaisseur\_tete / 2\])
rotate(\[90, 0, 0\])
cylinder(h = largeur\_tete, r1 = longueur\_tete / 2, r2 = longueur\_tete / 2, $fn = 100);
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/k7Fimage.png)
**pour la deuxième étape, j'ai créé le poignet de la raquette avec ce code:**
// Paramètres du poignet
longueur\_poignet = 140;
diametre\_poignet = 20;
// Création du poignet de la raquette de ping-pong
translate(\[longueur\_tete / 2, largeur\_tete / 2, epaisseur\_tete / 2 - longueur\_poignet\])
rotate(\[90, 0, 0\])
cylinder(h = longueur\_poignet, r = diametre\_poignet / 2, $fn = 100);
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/t0Eimage.png)
**Après, j'ai essayé de faire la réunion de ces deux parties précédentes avec le code suivant:**
// Paramètres de la tête de la raquette
longueur\_tete = 150;
// Longueur de la tête de la raquette
largeur\_tete = 70;
// Largeur de la tête de la raquette
epaisseur\_tete = 10;
// Épaisseur de la tête de la raquette
// Paramètres du poignet
longueur\_poignet = 180;
diametre\_poignet = 20;
// Création de la raquette complète
union() {
// Tête de la raquette
translate(\[longueur\_tete / 2, largeur\_tete / 2, epaisseur\_tete / 2\])
rotate(\[90, 0, 0\])
cylinder(h = largeur\_tete, r1 = longueur\_tete / 2, r2 = longueur\_tete / 2, $fn = 100);
// Poignet de la raquette (ajusté pour être collé à la tête)
translate(\[longueur\_tete / 2, largeur\_tete / 2, epaisseur\_tete / 2 + 1\]) // Ajustez la translation ici
rotate(\[180, 0, 0\])
cylinder(h = longueur\_poignet, r = diametre\_poignet / 2, $fn = 100);
}
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/aGtimage.png)
**16/11/2023**
##### **1) Impression d’un objet contenant d’autres objets solides non imprimés**
J'’ai choisi de réaliser un vase avec une particularité esthétique, dans laquelle je placerai des fleurs (mes objets non imprimés).
Code sur OpenScad :
// Paramètres du vase
diametre\_bas = 80;
diametre\_haut = 60;
hauteur\_vase = 120;
epaisseur\_parois = 5;
inclinaison\_col = 10; // Angle d'inclinaison du col
decoupes\_decoratives = 6; // Nombre de découpes décoratives à la base
// Définition du vase
module vase() {
difference() {
cylinder(h = hauteur\_vase, r = diametre\_bas / 2, $fn = 100); // Base du vase
translate(\[0, 0, hauteur\_vase - epaisseur\_parois\])
rotate(\[inclinaison\_col, 0, 0\]) // Inclinaison du col
cylinder(h = hauteur\_vase + epaisseur\_parois, r = diametre\_haut / 2, $fn = 100); // Partie supérieure pour créer le col du vase
// Ajout de découpes décoratives à la base
for (i = \[0:decoupes\_decoratives - 1\]) {
translate(\[cos(i \* 360 / decoupes\_decoratives) \* (diametre\_bas / 2 - epaisseur\_parois), sin(i \* 360 / decoupes\_decoratives) \* (diametre\_bas / 2 - epaisseur\_parois), 0\])
rotate(\[0, 0, i \* 360 / decoupes\_decoratives\])
cube(\[epaisseur\_parois \* 2, epaisseur\_parois \* 2, hauteur\_vase\]);
}
}
}
// Afficher le vase
vase();
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/EzYimage.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/vapimage.png)
##### **2) Faire un post traitement pour renforcer la cohésion**
**Pour renforcer la cohésion de mon objet, j'ai choisi la technique du post traitement d'insertion de composants et accessoires.**
**"Pour améliorer encore la fonctionnalité de mon objet imprimé en 3D , incorporer des inserts et du matériel est une excellente idée. Les accessoires peuvent être ajoutés pendant le processus d'impression ou après, en fonction des exigences du projet. En incorporant des pièces métalliques ou des éléments filetés, je peux créer des points de fixation sûrs, faciliter l'assemblage et améliorer l'intégrité structurelle."**
**https://www.nouvelleecole.fr/blog/post-traitement-3d**
# Jacqueline YOGENDRAN
### **Prototypage**
##### **18/10/2023 : 1er cours de prototypage**
- Premier cours sur la découverte du logiciel Openscad pour créer des objets en 3D
- Compréhension du langage
- Initiation à Ideamaker pour matérialiser notre l'objet afin de pouvoir l'imprimer
À l'issu de ce premier cours, nous avons 2 exercices à faire pour le cours du ***27/10/2023 :***
- **Réaliser un objet 3D sur Openscad en utilisant la différence ou l'addition.**
- **Réaliser un objet 3D sur Openscad. Celui-ci doit être uniquement réalisable via l'impression 3D**J'ai décidé alors de créer un parasol sur Openscad.
Voici ci-dessous **le code** :
//Construction de la tige du parasol
color("white") cylinder(h = 50, r1 = 3, r2 = 1);
//Ajout d'une base supplementaire
translate(\[0, 0, 3\])
color ("grey") cylinder(h=2, r=5);
//Construction de la base du parasol
difference() {
translate(\[0, 0, 0\])
color ("grey") cylinder(h=3, r=10);
}
//Construction du toit du parasol
translate(\[0, 0, 35\])
difference() {
color("pink") cylinder(h = 15, r1 = 30, r2 = 0)
sphere(20);
}
#####
##### **26/10/2023 : Impression de mon parasol**
L'impression a été une réussite au premier abord, cependant lorsque j'ai du enlever les supports, mon objet a été très fragile et s'est malheureusement cassé...
Voici un aperçu de ce qu'il en reste :
**Base du parasol :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-02/oT2image.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-02/jXlimage.png)
**Toit du parasol :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-02/7SVimage.png)
#####
##### **27/10/2023 : 2eme cours de prototypage**
1. **Discussion afin de pouvoir améliorer nos objets imprimés :**
- ajout de complexité
- possibilité de pouvoir imprimer avec 2 filaments différents
2. **Courte présentation des différentes techniques de post-traitements pour faire adhérer les couches entre elles :**
- Travailler avec le sable : permettre aux couches d'adhérer entre elles
- Travailler avec du solvant : permet d'obtenir de la transparence si on a utilisé un filament transparent
- Chaleur contrôlée
- Vernis ou laque acrylique
- Ponçage et polissage
**Pour le prochain cours :**
- **Réaliser un objet plus complexe : mettre un objet solide dans une impression 3D ou réaliser une impression bi-colore.**
- **Réaliser un post-traitement sur l'objet précédent. L'objectif est de le durcir et de renforcer la cohésion.**
#####
##### **14/11/2023 : Création de mon deuxième objet 3D sur OpenSCAD**
Voici **mon code** pour la création d'un sphère contenant une autre sphère :
//Création de l'objet
difference(){
color("white")sphere(r=20, $fn=100);
color("white") sphere(r=15.7,$fn=100);
color("white") cylinder(h=70,r=10.7, center=true, $fn=100);
color("white") rotate (\[90,0,0\]) cylinder(h=0,r=0, center=true, $fn=100);
color("white") rotate (\[0,90,0\]) cylinder(h=70,r=10.7, center=true, $fn=100);
}
// Ajout d'une sphère
color("pink") sphere(r=13.9,$fn=100);
#####
##### **16/11/2023 : 3eme cours de prototypage **
- Tour de table sur les différents objets conçus par les étudiants de la classe
- Introduction à Arduino
- apporte une aide intelligence à des objets que l'on peut fabriquer
**Pour le prochain cours :**
- **Étudier les ressources mises à disposition sur Moodle concernant les Arduino**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-02/AO9image.png)
##### **24/11/2023 : Atelier de prototypage avec Keyne Dupont**
##### **08/12/2023 : 4eme cours de prototypage**
**Présentation des outils web**
**Technologies web : **
- **Markup Language :** formater avec des balises
- **Cascading style sheets** : définir des styles
- **Javascript** **:** dynamiser les pages
Chaque page du site web est structuré suivant le DOM (document object model)
**Les applications web**
- **Site dynamique :** HTML, CSS, JS, Node
- **Transformateur du web en application :** PhoneGap, Cordova, Capacitor.
**Les framework Javascript :**
- Manipuler et éditer le DOM pour changer/ajouter/supprimer des éléments
Une seule application pour designer et développer.
App Inventor génère l'application :
- **En phase de test :** AppInventor génère un QR-code
- **En phase de développement :** AppInventor génère un fichier exécutable pour chaque architecture (App Store et Google Play)
**1ère u****tilisation de App Inventor : Création d'une application**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-12/yagimage.png)
# Grégoire SIMON
### **Prototypage**
#### **Séance du 18/10/2023**
Cette première séance de prototypage au FabLab a servis de séance d'introduction à ce que nous allions faire par la suite et comment. Nous avons donc découvert deux logiciels:
- Le premier est OpenScad, un logiciel de modélisation paramétrique dont nous avons appris les rudiments
- Le second est ideaMaker, un logiciel d'impression 3D dont nous avons aussi vu les bases et qui nous servira par la suite pour nos premières impressions.
#### **Séance du 27/10/2023**
Pour cette seconde séance de prototypage nous devions réaliser deux objets, l'un de notre choix et l'autre qui n'est faisable que par impression 3D. Voici donc les objets que j'ai décidé de faire.
##### **1) Objet de notre choix**
Le premier objet que j'ai choisis de faire est une sorte de jeu basé sur 2 objet: une base en forme de lampe torche et une boule. L'objectif du jeu serait alors très simple, essaye de faire tenir le plus longtemps possible la boule sur la base en tenant à bout de bras cette dernière. Voici le code utilisé sur OpenScad:
**Code:**
cylinder(10,10,20,true);
translate (\[0,0,-30\]) cylinder(50,5,5,true);
translate(\[0,0,13\]) sphere(7);
**Résultat sur OpenScad:**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/MMMimage.png)
**Résultat après impression:**
##### **2) Imprimer un objet uniquement faisable à l'imprimante 3D**
L'objet que j'ai décidé de faire ici est simplement un cercle composé d'un millier de dents minuscules. L'idée derrière cette réalisation est de faire une sorte d'engrenage hyper précis. Pour cela, j'ai réaliser le code suivant sur OpenScad.
**Code:**
// Paramètres du cercle
taille = 50; // Taille du cercle
nombre\_dents = 1000; // Nombre de dents
// Fonction pour créer un cercle avec des dents
module etoile\_avec\_dents() {
difference() {
union() {
for (i = \[0:nombre\_dents - 1\]) {
rotate(\[0, 0, i \* 360/nombre\_dents\])
translate(\[0, taille / 2, 0\])
rotate(\[0, 0, -45\])
scale(\[1, 0.4, 1\])
square(\[taille, taille\], true);
translate(\[0, taille / 2 + 5, 0\]) // Ajustez la valeur 5 pour l'espacement des dents
rotate(\[0, 0, i \* 360/nombre\_dents\])
rotate(\[0, 0, -45\])
scale(\[0.2, 0.2, 1\])
square(\[taille, 2, 5\]);
}
}
circle(taille/2, true);
}
}
// Affiche le cercle avec des dents
etoile\_avec\_dents();
**Résultat sur OpenScad:**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/aHXimage.png)
**Résultat final:**
##### **3) Contenu de la séance**
On peut travailler nos objets avec des filaments différents. Pour cela, dans ideaMaker, on peut spécifier aux 2 extrudeurs de la machines (gauche et droite) si on utilise 2 matériaux différents, les valeurs changent. On peut garder le même code, le couper en 2 puis insérer le nouvel objet à créer et l'insérer à côté de l'ancien sur ideaMaker.
De plus, il peut être intéressant de faire du post-traitement de nos produits. Par exemple, il peut être utile de travailler avec du sable avec le protocole suivant: prendre l'objet, le mettre dans un bécher avec du sable, on tasse puis on met au four à 110°, le PLA va se ramollir un petit peu et permettre aux couches d'adhérer entre elles. On peut aussi travailler avec du solvant car ce dernier s'évapore avec la chaleur, ce qui permet d'obtenir de la transparence si on a utilisé un filament transparent.
#### **Séance du 16/11/2023**
Pour cette séance nous devions faire un objet dans lequel on doit insérer un autre et, faire en sorte que cet objet soit bicolore. Je me suis alors dit assez vite que je voulais faire un oeuf KinderSurprise. J'ai assez facilement trouvé le modèle que je souhaitais en ligne et ai simplement séparé les deux morceaux pour faire en sorte d'ensuite pouvoir imprimer de couleur différente les deux morceaux.
##### **Résultat sur ideaMaker:**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/qEximage.png)
##### **Résultat final:**
# Justine LANNI
**Séance du 18/10/2023 :**
Au cours de cette séance, le fonctionnement de OpenSCAD et de IdeaMaker nous a été présenté. Quelques fonctions de base nous ont également été introduites.
**Séance du 28/10/2023:**
Pour cette séance, il s'agissait de réaliser 2 objet : un objet montrant qu'on a compris le principe de soustraction et d'addition et un objet réalisable uniquement en impression 3D. J'ai donc choisi de créer une perle et une souris.
- **La perle :**
Voici le code que j'ai utilisé sur OpenSCAD :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-16-09-01-39.png)
- **La souris :**
Voici le code que j'ai utilisé :
module corps\_souris() {
union() {
// Corps de la souris
scale(\[2, 2, 2\])
sphere(9);
// Tête de la souris
translate(\[0, 0, 25\])
scale(\[1, 1, 1\])
sphere(10);
}
}
module oreilles\_souris() {
union() {
for (angle = \[30, 150\]) {
rotate(\[0, 0, angle\])
translate(\[13, 0, 27\])
scale(\[1, 1, 1\])
circle(5);
}
}
}
module yeux\_souris() {
translate(\[-2, 3, 34\]) {
for (angle = \[0, 180\]) {
rotate(\[0, angle, 0\])
cylinder(h=1, d=3);
}
}
}
module yeux\_souriss() {
translate(\[3, 3, 34\]) {
for (angle = \[0, 180\]) {
rotate(\[0, angle, 0\])
cylinder(h=1, d=3);
}
}
}
module queue\_souris() {
translate(\[0, 0, -40\])
cylinder(h=60, d1=2, d2=1);
}
module souris() {
union() {
corps\_souris();
oreilles\_souris(); // Ajout des oreilles
yeux\_souris(); // Ajout des yeux
yeux\_souriss(); //ajut de l'oeil 2
queue\_souris();
}
}
souris();
On obtient cette représentation sur OpenSCAD avec ce code :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-16-09-24-58.png)
# ORKUSH Iryna
**Prototypage**
Lors de la séance d’introduction nous avons appris les bases sur OpenScad et IdeaMaker, telles que l’utilisation et le paramétrage des différentes figures géométriques, leur duplication, ainsi que l’application des fonctions difference, translate et rotate sur ces dernières.
**Séance 1 : 27/10**
**Prototypage d’une gourde**
Grâce à ces outils, nous devions mettre en place un objet de notre choix. Voici un bout de code de ma fonction.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/kTAimage.png)
**Résultat :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/PMEimage.png)
**Attention :** l'objet n'est pas imprimé avec les couleurs telles que représentées sur l'image. Il faudra faire des réglages sur IdeaMaker avant l'impression pour les changements de couleurs.
**Séance 2 : 16/11**
Par la suite, il nous a été demandé de concevoir un autre objet mais qui serait plus complexe à imprimer (par exemple, arrêt de l'impression de l'objet à un certain moment pour insérer un autre objet à l'intérieur ou encore impression en plusieurs couleurs, en dégradé ou utilisation d'au moins 2 matières différentes). Tous ces paramètres sont réglables sur IdeaMaker ou sur l'imprimante 3D directement.
**Prototypage d’un porte-clé ourson**
Voici un extrait de code que j'ai obtenu pour mon ourson :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/JHLimage.png)
Voici un extrait de code que j'ai obtenu pour créer la chaîne du porte-clé :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/tUTimage.png)
**Résultat :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/RVgimage.png)
Cependant, il est à noter que lors de l'impression, la chaîne est susceptible de se casser en raison de sa finesse et donc de sa fragilité. Pour cela, il faut par exemple utiliser des matériaux plus résistant comme le PLA par exemple, que j'ai également utilisé pour imprimer mon premier objet (PLA Noir). On peut également penser à intégrer un support le long de la chaîne pour renforcer les zones les plus fragiles.
# Hayet BENSEDDIK
Dans le cadre de l'UE Processus d'innovation,
**1ère partie : conception et fabrication additive (impression 3D).**
**18/10/23: Cours 1**
- Découverte des logiciels OpenScad et IdeaMaker
- Modélisations simples sur OpenScad
**24/10/23:** Impression en 3D de nos premières modélisations
*Pour ma première modélisation, il est à noter que j'ai pris beaucoup de temps pour modéliser. Les représentations à partir d'un langage codé ne sont pas mon point fort mais après plusieurs tentatives j'ai réussi à comprendre le fonctionnement qui, en réalité est plus simple. Après cette première impression, j'ai pu paramétrer des objets plus techniques.*
Pour la première fois, je voulais réaliser quelque chose de basique comme mon prénom en toute lettres, sauf que la surprise était lors de l'impression 3D où le logiciel m'a informé qu'il fallait **320 jours d'impression** ! Je me suis donc tourné vers la création d'objet simple pour m'entrainer et ensuite passer à un niveau supérieur.
```
content = "HAYET";
font = "comic sans ms";
translate ([-20,0,0]) {
linear_extrude(height = 3) {
text(content, font = font, size = 10);
}
}
```
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/1openscad.png)
Mon première objet est une cuve cylindrique.
**07/11/23:** Réalisation d'un objet solide dans une impression 3D
Pour cette deuxième phase, j'ai modélisé un cube à paroi sphérique contenant un objet solide à l'intérieur. Pour ce faire j'ai d'abord modéliser la sphère, ensuite j'ai lancer l'impression du cube. A la moitié de l'impression du cube j'ai stopper la machine pour y insérer ma sphère.
Et en second lieu, j'ai créée une espèce de roue, à vue d'œil on a l'impression qu'elle tourne.
08/12/2023
Pour cette seconde partie de cours, le but était par une création Arduino faire fonctionner une lampe pour qu'elle clignote.
```
const int LED=12;
void setup(){
pinMode(LED, OUTPUT); //on l'active
}
void loop(){
digitalWrite(LED, HIGH); //on l'allume
delay(200); //on attend
digitalWrite(LED, LOW); //on l'éteint
delay(200); //on attend
}
```
# Arielle Gal
### **PROTOTYPAGE**
### **18 / 10 / 2023 - 1ère séance au FabLab**
##### **Open SCAD** = logiciel de code
- Un langage propre qui permet a définir des formes géométriques
- Prepare des formats STL pour IdeaMaker
##### **IdeaMaker** = Logiciel d’impression 3D
- Peut créer des supports nécessaires pour des modèles complexes
- Prepare le format pour l’imprimante 3D
##### *Pour la semaine prochaine:*
1 Imprimer un objet de notre choix
2 Imprimer un objet infaisable sans imprimante 3D
### **25 / 10 / 2023 - Impression 3D**
##### **1. Imprimer un objet de notre choix**
L’objet que j’ai decider de imprimer est un palmier que j'ai codé avec open SCAD. Et que j'ai imprimé en 3D à l'aide du logiciel ideaMaker.
##### **Code** **:**
**Le code créé pour imprimer un modèle 3D d'un palmier:**
$fn = 200; // Resolution
module palmier() {
sand\_platform();
solid\_trunk();
for (i = \[0:5\]) {
rotate(\[0, 0, i \* 60\])
feuille();
}
}
module sand\_platform() {
color("khaki") // Sand color
translate(\[0, 0,100\])
scale(\[1, 1, 0.3\])
sphere(40);
}
module solid\_trunk() {
color("brown")
cylinder(h=100, r=7);
}
module feuille() {
color("green")
translate(\[0, 0, -5\])
rotate(\[180, 0, 0\])
translate(\[0, 30, 0\])
scale(\[1, 3, 1\])
for (i = \[-1, 1\]) {
rotate(\[0, i\*45, 0\])
cylinder(h=1, r1=0, r2=20);
}
}
// Render the palm tree
palmier();
##### **Mon objet sur Open SCAD** **:**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/screenshot-2023-11-16-at-2-45-09-pm.png)
Format .stl de mon palmier.
##### **Mon objet 3D** **:**
Le palmier a été imprimé et la plateforme de sable ainsi que le tronc étaient stables. Cependant, l'épaisseur des feuilles était trop mince, donc l'objet n'a pas pu être imprimé correctement. De plus, les détails des feuilles étaient trop compliqués pour être correctement imprimés par la machine.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-02/screenshot-2024-02-14-at-7-25-15-am.png)
#### **2) Imprimer un objet infaisable sans imprimante 3D**
##### **Code** **:**
##### **Visualisation sur Open SCAD****:**
##### **Résultat final** **:**
### **27 / 10 / 2023 - 2ème séance au FabLab**
##### **Améliorer nos objets imprimés:**
- travailler avec 2 filaments différents (si on travaille avec 2 matériaux différents…les valeurs changent.
- Differents méthodes de post-traitent:
- Lissage avec du solvant
- Polissage mécanique
- Vaporisateurs adhésifs
- Chauffage du plateau d’impression
- Modification des paramètres d’impression
- Utilisation de l’aide à la dissolution
##### *Pour la semaine prochaine:*
1 Créer un object dont ont met l’impression en pause puis on met un autre objet à l’intérieur avant de finir l’impression.
2 Faire un post traitement sur l’ancien object pour faire mieux tenir entre elles les couches.
#### **Impression 3D**
Avec Ossian BENGSTON, nous avons pensé à faire une sphère vide avec un manche afin de faire des maracasses avec une pause d'impression afin d'y placer différents objets à l'intérieur.
##### **Code** **:**
$fn=200; // Augmenter le nombre de faces pour une sphère plus lisse
R = 40; // Rayon externe de la sphère
epaisseur = 2; // Épaisseur des parois de la sphère
// Créer une sphère vide
difference() {
sphere(R); // Sphère externe
sphere(R - epaisseur); // Sphère interne à soustraire
}
translate(\[0, 0, -80\])cylinder(100,10,20,center=true);
$fn=200; // Augmenter le nombre de faces pour une sphère plus lisse
R = 40; // Rayon externe de la sphère
epaisseur = 2; // Épaisseur des parois de la sphère
// Créer une sphère vide
difference() {
sphere(R); // Sphère externe
sphere(R - epaisseur); // Sphère interne à soustraire
}
translate(\[0, 0, -80\])cylinder(100,10,20,center=true);
##### **Notre objet sur Open SCAD** **:**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/cmLimage.png)
#### **Notre objet sur IdeaMaker** **:**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/ace3882f-fafd-4f55-b40f-1d7528941a9e.JPG)
Pour réduire le temps on a réduit la taille du objet sur Idea Maker.
Nous avons programmé une pause temporaire dans l'impression 3D afin d'insérer de petites vis, qui servent de source sonore pour les maracas. Arrêt de l'impression lorsque 2/3 de la sphère s'est formée.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/screenshot-2023-11-17-at-12-05-23-am.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/screenshot-2023-11-17-at-12-06-23-am.png)
##### **Résultat final** **: **
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/screenshot-2023-11-17-at-12-12-02-am.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/screenshot-2023-11-17-at-12-12-28-am.png)
Les maracasses après 1h et 16 min.
# Kelly LUSINIER
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-05-a-20-14-18.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-11/capture-decran-2023-11-05-a-20-43-43.png)
# Soafaranirina Diagne
**18/10/23 :** Cours
- Découverte d'OpenSCAD et d'IdeaMaker
- Opérations simples sur OpenSCAD
**27/10/23:**
- Devoirs : Imprimer en 3D un objet original conçu avec OpenSCAD + un objet qui soit impossible à construire sans l’impression 3D.
- Présentation des réalisations à la classe
- Présentation du fonctionnement de l'imprimante 3D et des différents fil que l'on peut utiliser
- Consigne : réaliser un objet en bi-colore dans lequel on peut insérer un autre objet en arrêtant l'impression 3
**Réalisation d'u objet complexe: Sommier d'un lit**
code :
length=60;
linear\_extrude(height = 3, center = false)
difference() {
square(\[length,40\],center);
for ( i = \[1 : (length / 3)\] ){
translate(\[i\*3,4,0\]) {
square(\[1,32\]);
}
}
}
cube(\[length,1,1\]);
translate(\[0,40,0\]) {
cube(\[length,1,1\]);
}
cube(\[1,40,1\]);
translate(\[length-1,0,0\]) {
cube(\[1,40,1\]);
}
module prism(l, w, h){
polyhedron(
points=\[\[0,0,0\], \[l,0,0\], \[l,w,0\], \[0,w,0\], \[0,w,h\], \[l,w,h\]\],
faces=\[\[0,1,2,3\],\[5,4,3,2\],\[0,4,5,1\],\[0,3,4\],\[5,2,1\]\] );
}
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-09/KCgimage.png)
J'avais comme projet de construire un lit en miniature semblable au lego.
Ce sommier en aurait été la base. Visuel de l'objectif que je voulais atteindre:
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-09/HJmimage.png)
**J'ai néanmoins pu imprimer le socle du lit:**
**Je n'ai pas pu retrouver le code cependant.**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-09/9Kqimage.png)
**Réalisation d'une limousine:**
**Je n'ai malheureusement pas pu réaliser les fenêtres de la voiture ainsi que les portes**
code:
cube(\[90,20,15\],center=true);
translate(\[5,0,10 - 0.001\])
cube(\[70,20,10\],center=true);
translate(\[-20,-15,0\])
rotate(\[90,0,0\])
cylinder(h=3,r=8,center=true);
translate(\[-20,15,0\])
rotate(\[90,0,0\])
cylinder(h=3,r=8,center=true);
translate(\[20,-15,0\])
rotate(\[90,0,0\])
cylinder(h=3,r=8,center=true);
translate(\[20,15,0\])
rotate(\[90,0,0\])
cylinder(h=3,r=8,center=true);
translate(\[-20,0,0\])
rotate(\[90,0,0\])
cylinder(h=30,r=2,center=true);
translate(\[20,0,0\])
rotate(\[90,0,0\])
cylinder(h=30,r=2,center=true);
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-09/gw6image.png)
# Sarah Kolli
# Yokhébed BAYEYE
**18/10/2013 – 1ère séance de prototypage au FABLAB**
Pour notre première séance nous avons découvert les logiciels OpenSCAD et IdeaMaker .
**27/10/2023 – Séance 2**
Consigne : Réaliser un objet de notre choix en 3D conçu avec OpenSCAD
Pour mon premier objet, j’ai décidé de réaliser une bague sur laquelle on retrouve une pièce au dessus en forme de diamant.
Voici le code :
translate(\[0,0,4\]){
scale(\[.5,.5,.5\]){
translate(\[0,0,10\]){
cylinder(10,r1=0.1,r2=10,true,$fn=10);
difference(){
translate(\[0,0,15\]){
rotate(\[0,180,0\]){
cylinder(5,r1=10,r2=10,true,$fn=10);}}
translate(\[0,0,22\]){
cube(20,true);}}}}}
translate(\[3.5,0,0\]){
rotate(\[0,-90,0\]){
translate(\[0,0,2\]){
difference(){
linear\_extrude(3,true){
circle(10,$fn=1000);}
linear\_extrude(5,true){
circle(8,$fn=1000);}}}}}
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-09/capture-decran-2024-09-09-a-17-49-33.png)
**15/11/2023 : Séance 3**
La consigne pour cette séance était de créer un objet en interrompant l'impression à mi-parcours, puis d'insérer un autre élément à l'intérieur avant de reprendre l'impression.
Pour cela, j'ai conçu une sphère avec des ouvertures permettant d'insérer une autre sphère à l'intérieur.
Voici le code :
difference(){
sphere(r=20, $fn=100);
sphere(r=15,$fn=100);
cylinder(h=70, r=10, center=true, $fn = 100)
rotate (\[90,0,0\]) cylinder(h=70,r=10, center=true, $fn = 100);
rotate (\[0,90,0\]) cylinder(h=70,r=10, center=true, $fn = 100);
}
sphere(r=10, $fn=100);
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-09/capture-decran-2024-09-09-a-19-18-55.png)
# Charlotte Forge
**Objet n1 : objet réalisé sur open scad :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-09/0Kkimage.png)
Porte clé, le code que j'ai saisi était le suivant :
$fn = 20;
difference () {
hull () {
# translate(\[0,0,0\]) cylinder(r=2,h=3);
translate(\[10,0,0\]) cylinder(r=2,h=3);
translate(\[5,40,0\]) cylinder(r=4,h=3);
}
translate(\[5,38,-1\]) cylinder(r=1,h=5);
}4
**Objet 2, objet uniquement réalisable avec imprimante 3D ou objet dans autre objet :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-09/capture-decran-2024-09-09-a-22-49-59.png)
code :
translate(\[-24,0,0\]) {
union() {
cube(16, center= true);
sphere(11);
}
}
# Mariia Karpenko
### **Création d'objets 3D**
#### **Etape 1 : faire un objet simple 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 :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/2026-01-01-16-15-47.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/2026-01-01-16-22-15.png)
#### **Objet terminé :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/5384289724211597063.jpg)