Groupe B1

Nom des participants :

• MABIRE Léna 
• OLAGNIER Nans
• PENOT Léonard 
• TROUDE Thibault 

Séance 1 : Présentation de l'UE et du FABLAB

(Espace de détente à l'entrée du Fablab)

Nous avons commencé cette première séance de l'UE LU1SXPFL, qu'on appelle plutôt "Projet Fablab" en découvrant le principe du Fablab, que l'on peut résumer en un bac à sable scientifique accessible à tout niveau, et que l'on peut utiliser en respectant le principe d'ouverture et de partage. Dans l'Openspace du Fablab, on a accès à diverses machines (imprimante 3D, fraiseuse numérique, découpeuse laser, etc...) afin de faire, comme le disait Neil Gershenfeld, le professeur au M.I.T. créateur du concept des Fablabs : "anything [we want]", soit "tout [ce qu'on veut]". 

Le plus important à retenir est que dans cette UE, et dans notre utilisation du Fablab en général, même pour un usage personnel, il faut entretenir ce wiki, et accompagner nos projets d'une documentation la plus précise possible afin que chacun, même dans le futur, puisse utiliser ce que nous avons fait, comme nous utilisons ce que d'autres ont fait dans le passé. 

(Imprimantes 3D du FabLab)

Séance 2 : Découverte des logiciels de dessin

Lors de la deuxième séance du Projet Fablab, nous avons appris à utiliser 3 logiciels de dessin numérique : Inkscape pour le dessin 2D, ainsi que OpenSCAD et FreeCAD pour le dessin 3D. A la fin de la séance, on nous as montré comment utiliser les différentes machines que nous aurons à notre disposition lorsque nous mettrons en oeuvre notre projet : imprimante 3D et découpeuse laser.

Commençons par décrire un peu les logiciels : Inkscape est un logiciel de modélisation numérique en 2 dimensions. Pour faire simple, c'est de la géométrie dans un plan en 2 dimensions. L'utiliser nous permettra de faire les plans à mettre dans la découpeuse laser.

Voici ci-dessus le dessin que nous avons réalisé pendant le cours. Notre professeur nous avait demandé de faire seulement un rectangle avec des cercles à l'intérieur, mais nous avons voulu nous amuser en creusant les coins et en ajoutant des rectangles sur les côtés pour agrandir ou rétrécir la pièce, comme un puzzle.

Ensuite, nous avons appris à utiliser le logiciel OpenSCAD. C'est un logiciel de modélisation en 3 dimensions, cette fois, et qui est basé sur du codage. Ainsi, on peut avec ce logiciel créer des formes plus ou moins complexes dans les 3 dimensions d'un plan, avec simplement quelques lignes de code (cela peut sembler compliqué, mais ça ne l'est pas tant que ça en vérité, les lignes de code sont simples à comprendre et à utiliser). 

Voici pour illustrer une création que nous avons fait ainsi que le code qui nous as permis de la produire. Normalement, en copiant exactement le même code sur OpenSCAD, vous devriez obtenir le même résultat (à la seule différence que l'image de gauche est tirée de la visionneuse 3d de Windows 11 avec le fichier STL créé avec ce code, car le rendu est plus joli que celui directement disponible sur le logiciel OpenSCAD). Notre professeur nous demandait uniquement de trouer un carré, mais nous avons aussi voulu aller plus loin, en créant des carrés et des sphères, et en les emboîtant les uns dans les autres

$fn=300;

module coque(){
difference(){
sphere(d=30);
translate([0,0,-16])cylinder(h=40,r=9);
    rotate([0,90,0])translate([0,0,-16])cylinder(h=40,r=9);
    rotate([90,0,0])translate([0,0,-20])cylinder(h=40,r=9);
};
};
difference(){
coque();
sphere(d=28);    
};
module tesseract(){
rotate([45,45,45])difference(){
cube(12,center=true);
    translate([0,0,-8])cylinder(h=30,r=5);
    translate([-12,0,0])rotate([0,90,0])cylinder(h=30,r=5);
    translate([0,12,0])rotate([90,0,0])cylinder(h=30,r=5);
    sphere(d=15);
};
};

tesseract();
module boule(){
    rotate([-45,-45,-45])difference(){
sphere(d=9);
translate([0,0,-16])cylinder(h=40,r=2.7);
    rotate([0,90,0])translate([0,0,-16])cylinder(h=40,r=2.7);
    rotate([90,0,0])translate([0,0,-20])cylinder(h=40,r=2.7);
        sphere(d=8);
};
};
boule();
cube(3,center=true);
sphere(d=3.5);

En soit ici, le code est globalement le même pour chaque partie de la figure, si ce n'est que nous n'utilisons pas les mêmes figures géométriques à chaque fois. 

Le troisième logiciel que nous avons appris à utiliser est FreeCAD qui est aussi un logiciel de modélisation 3D. C'est aussi un logiciel dit paramétrique comme OpenSCAD à la différence que FreeCAD n'est pas basé sur le codage mais sur l'utilisation de fonction comme la création de bloc, l'extrusion et autres. Bien que cela paraisse plus simple que OpenSCAD, le logiciel FreeCAD est moins intuitif et donc plus difficile à prendre en main. 

(Modèle fait avec FreeCAD)

Enfin, nous avons terminé la séance en découvrant un peu le fonctionnement des machines. Nous ne détaillerons pas ici la façon exacte d'utiliser l'imprimante 3D et la découpeuse laser. Tout ce que nous dirons, c'est que ces machines sont assez impressionnantes (notamment la découpeuse laser, qui nous as laissés bouche bée par sa rapidité et sa précision). 

Séance 3 : Découverte de l'Arduino

Lors de la troisième séance, nous avons appris les bases de codage d'une carte Arduino et des différents capteurs qui peuvent lui être attachée. 

Tout d'abord, on nous a distribué du matériel : une carte Arduino, des câbles, une LED, des résistances... tout ce qu'on utilise comme matériel en temps normal en cours d'électronique (mis-à-part l'Arduino qui est nouveau pour nous). L'Arduino, c'est un système reposant sur deux choses : un logiciel pilotable depuis l'ordinateur (gratuit) et une carte que l'on peut brancher directement à l'ordinateur. Le mélange de ces deux choses, et quelques connaissances de base en électronique, nous permettent de faire ce qu'on appelle de "l'électronique embarqué", c'est-à-dire de l'électronique, mais qu'on peut facilement faire à la maison, sans avoir besoin de tout le matériel des TP d'électro qu'on fait sur le campus de la fac. 

Alors immédiatement, on a appris à faire utiliser l'Arduino. On a commencé par faire le circuit "Blink". C'est l'équivalent en Arduino du "Hello World" dans les autres langages de programmation. Le but est très simple : faire clignoter une LED. 

Après avoir fait ce code, on a continué sur un circuit un peu plus utile : en branchant un capteur d'humidité et de température sur notre Arduino, on a pu contrôler à chaque seconde l'humidité et la température autour du capteur. 

Séance 4 : Début du projet en groupe

Dans cette séance nous avons commencé à préparer notre projet en groupe. Notre idée a été de faire un gravimètre (et détecteur de planètes). L'objectif est donc, à la fin de notre projet, d'obtenir un capteur capable de nous donner l'accélération de la pesanteur, et donc de nous indiquer sur quelle planète on se trouve. 

Voici un premier schéma de notre idée (sans beaucoup de développement :

L'idée est la suivante : on fait tomber un accéléromètre, et avec une étude mécanique, on réussit à trouver l'accélération de la pesanteur (l'idée serait de supprimer l'incidence des frottements et de la poussée d'Archimède). Pour cela, on a eu l'idée de fixer l'accéléromètre sur un support mobile, que l'on pourrait facilement faire tomber à l'intérieur d'un tube (que l'on pourrait créer nous-même avec l'imprimante 3D et la découpeuse laser). Avec un baromètre (placé en haut), on pourrait connaître la pression pour calculer la poussée d'Archimède. Ensuite, en reliant le tout à une carte Arduino, on pourrait envoyer les données sur un écran, et afficher ainsi la valeur de g (l'accélération de la pesanteur). En mettant dans une base de donnée les valeurs tabulées des accélérations de pesanteur des différentes planètes du système solaire, par comparaison, notre système pourrait nous dire sur quelle planète on se trouve. 

Cependant, en fin de séance, on s'est rendu compte que l'accéléromètre qu'on souhaitait utiliser nous donnait déjà, sans aucun mouvement, l'accélération de la pesanteur. Notre projet, dans sa conception, ne sert donc à rien et il faut le changer. Une de nos idées est de partir sur un capteur de distance et de mouvement. 

Séance 5 : Gravimètre, équations et impression

Notre première idée n'ayant pas abouti, nous avons commencé cette séance en réfléchissant à comment faire notre gravimètre, mais sans accéléromètre. Après avoir réfléchi à un capteur de distance, nous sommes finalement partis sur une idée de capteur de présence. Voici l'idée : dans un tube d'une soixantaine de centimètres, on place trois capteurs de présence : deux tout en bas du tube, très proches l'un de l'autre, et un tout en haut du tube. Une fois cela fait, grâce à un ressort nous envoyons une petite boule de métal par le bas du tube monter jusqu'au 3e capteur, puis redescendre. 

Les deux premiers capteurs nous permettent de calculer la vitesse initiale de la boule, le 3e capteur nous permet, grâce au temps que la boule a mis pour atteindre le haut, de connaître l'accélération de la pesanteur (on néglige toute autre force, comme la poussée d'Archimède et les frottements pour le moment parce qu'ils sont compliqués à calculer et surtout assez négligeables ; on les rajoutera dans nos calculs à la fin du projet si nous avons le temps). 

Voici ci-dessous un schéma de travail de notre système. C'est Léonard et Nans qui ont fait ce schéma, et Thibault et Léna qui ont par la suite aidé à le fignoler en fonctions des différentes valeurs que l'on devait avoir avec les capteurs :

Et ci-dessous, une photo du tableau sur lequel nous avons réfléchi aux calculs que l'on devrait faire avec les capteurs : 

La valeur α est la hauteur, tandis que t est le temps. Pour les valeurs, α1 correspond à la hauteur du premier capteur, α2 à celle du 2e et α3 à celle du 3e tandis que les temps t1, t2 et t3 correspondent aux instants où la bille en métal passe devant les capteurs 1, 2 et 3. 

Grâce aux capteurs 1 et 2, on calcule avec le Théorème des Accroissements Finis la valeur v0, la de la boule lorsqu'elle est au premier capteur (en vérité, ce n'est pas exactement ça, mais on placera les capteurs suffisamment proche pour qu'on puisse l'approximer). Ensuite, en connaissant le temps t3 où la boule arrive au 3e capteur, on finit par trouver la dernière formule pour trouver g, l'accélération de la pesanteur. On a retrouvé cela en faisant une analyse mécanique et cinématique de la situation, en considérant que la boule n'est soumise qu'à son propre poids. 

À la fin de la séance, Léna et Thibault avaient réussi à faire fonctionner les capteurs tandis que Nans et Léonard ont imprimé une première pièce de la machine finale, à savoir le support de la boule, qui accroché au ressort, permettra d'envoyer la boule faire une chute libre. Voici la pièce : 

Sur cette photo la modélisation de la pièce sur IdeaMaker. On ne le voit pas bien, mais c'est un cylindre avec un trou en son centre pour que la boule y tombe et une surface en hauteur légèrement creusée, afin d'être sûr que la boule, lorsqu'elle y reviendra, parte du milieu.

Voici le code utilisé pour modéliser la pièce (sur OpenSCAD) : 

$fn=100;

module cylindre(){
difference(){
cylinder(h=1,d=3);
    translate([0,0,1])resize([3,3,0.5])sphere(d=2);
    translate([0,0,0.5])sphere(d=0.75);
};
};

cylindre();

Séance 6 : Prototypage

Maintenant que toute la partie la plus théorique était au point, était venue l'heure du prototypage. Au début de la séance, Thibault et Léna ont donc commencé par essayer de faire fonctionner correctement les capteurs ensemble (faire fonctionner un seul capteur n'est pas en soit d'une très grande difficulté, mais en faire fonctionner trois simultanément et les uns en fonction des autres l'est plus). 

Pendant ce temps, Léonard et Nans ont commencé le prototypage "matériel" en tentant de faire, mais sans encore de grande précision, la partie basse, ou "support" sur lequel on doit poser la plateforme de la boule/bille. 

Codage : 

unsigned T1;
unsigned T2; 
unsigned vitesse ;
bool variable1 = true ;
bool variable2 = true ; //description des variables et départ des variables bolléennes en vrai 

void setup()  {
    Serial.begin(9600);
    pinMode(6,INPUT);
}
void loop()  {
        delay(500);
        if (variable1 ==true){ // tant que la première variable est vrai 
            
            if(digitalRead(6)==LOW)  {  //Si un objet passe devant le premier détecteur 
            Serial.println("yes1");
            T1 = millis();              // On extrait le temps auquel l'objet est passé devant le détecteur et on met la variable en fausse pour que cette partie de la boucle s'arrete 
            variable1 = false; 
            }
            else  {
            Serial.println("No1");
       }
        }
        if (variable2 ==true){ // 
        
            if(digitalRead(7)==LOW)  { //Si un objet passe devant le second détecteur 
            Serial.println("yes2");
            T2 = millis();             // On extrait le temps auquel l'objet est passé devant le détecteur et on met la variable en fausse pour que cette partie de la boucle s'arrete 
            variable2 = false; 
            }
           else  {
           Serial.println("No2");
            }
        }
        if (variable1 ==false and variable2 ==false ){  // Une fois que l'objet est passé devant les deux détecteurs, on calcule sa vitesse  
         vitesse = 1/ (T2 - T1) ;
         Serial.println("vitesse =");
         Serial.println (vitesse); 
         }
 }

Code prototype calcul vitesse initial 

Pour ce code le but est de déterminer la vitesse initiale du projectile. Pour cela, il décrit un fonctionnement assez simple : 

• On détermine le temps T1, le moment le projectile passe devant le premier capteur.
• On détermine ensuite le temps T2, moment où le projectile passe devant le deuxième capteur.
• Enfin on calcule la vitesse en connaissant la distance entre les deux capteurs. 

On utilise pour cela des variables booléennes pour ne calculer les temps T1 et T2 une seule fois et éviter de fausser notre calcule si un capteur se rallume et ne change donc la valeur de temps stocké. 

PS : ce code ne fonctionne pas encore. 

Séance 7 : Montage final, première partie

La séance d'aujourd'hui avait pour but d'imprimer et de découper les pièces qui nous manquaient. En effet, maintenant que le programme est terminé et que tout est prévu, il nous faut tout découper et imprimer pour créer notre gravimètre.

D'abord, nous avons fini d'imprimer notre système de "catapulte", c'est à dire le système qui va lancer une bille en l'air. Pour cela, nous avons décidé de reprendre presque à 0, juste en gardant le principe. Nous avons donc créé un nouveau support, avec un genre de rail pour qu'il reste bien droit tout au long de son chemin. Voici le code utilisé : 

$fn=100;

module support(){
    cylinder(h=2,r1=1,r2=1);
 translate([0.8,-0.25,0])cube([0.4,0.5,1.9]); 
  translate([-1.2,-0.25,0])cube([0.4,0.5,1.9]);
  translate([-0.25,-1.2,0])cube([0.5,0.4,1.9]);
  translate([-0.25,0.8,0])cube([0.5,0.4,1.9]);
    
};

module support2(){
    difference(){
        support();
        translate([0,0,2])resize([2.5,2.5,0.5])sphere(1);
      translate([0,0,1.5])sphere(0.5); 
        resize([0.5,0.5,1])sphere(0.25);
    };
    translate([-0.25,-0.25,0])cube([0.25,0.5,0.1]);
};
support2();
module creuset(){
 cylinder(h=2,r1=1.05,r2=1.05);
 translate([0.8,-0.30,0])cube([0.45,0.6,1.5]); 
  translate([-1.25,-0.3,0])cube([0.45,0.6,1.5]);
  translate([-0.3,-1.25,0])cube([0.6,0.45,1.5]);
  translate([-0.3,0.8,0])cube([0.6,0.45,1.5]);
};
//creuset();
module corps(){
    difference(){
    cylinder(6,r1=1.7,r2=1.7);
        for(i=[-1:1:5]){
            translate([0,0,i])creuset();
        };
    };
};

module couloir(){
    difference(){
      corps();
      translate([0,0,6])resize([3.5,3.5,0.5])sphere(1);  
    };
};
couloir();

Le fichier en .scad utilisé sur OpenSCAD est le suivant : support-couloir.scad

Ensuite, nous avons utilisé un programme trouvé sur un autre article du FabLab pour créer notre base et notre "tour" à l'aide de la découpeuse laser. 

Projet personnels : 

En plus du projet de groupe, il nous est demandé de faire deux projets personnels ; créer une illustration en 2D et modéliser un objet en 3D. Le but de ces deux projets est de nous familiariser avec les logiciel de modélisation présenter au dessus mais aussi d'apprendre à nous servir des imprimantes 3D et de la découpeuse laser présentes au fablab. 

module rame(){
  cube([4.5,14,5]);  
};

module cut(){
    translate([-1,0,0])rotate([0,-10,-90])cube([3,6,10]);
      translate([-1,0.7,0])rotate([0,20,-90])cube([3,6,10]);
};
module rame2(){
  difference(){
    rame();
      cut();
      translate([4,14,0])rotate([0,0,180])cut();
  };  
};

//rame2();

module porte(){
    translate([-1,3,1])cube([6,1.5,3]);
    translate([-1,10,1])cube([6,1.5,3]);
};
//porte();

module fenetresp(){
  translate([-2,3.1,2.5])cube([8,1.3,0.9]); 
  translate([-2,10.1,2.5])cube([8,1.3,0.9]);  
};
//fenetresp();

module fenetresr(){
      for(i=[4.6:1:9]){
      translate([-1,i,1.5])cube([8,0.94,3]);
    };  
    translate([-1,1.2,2.2])cube([8,0.5,1.2]);
    translate([-1,12.2,2.2])cube([8,0.5,1.2]);
};
//fenetresr();

module fenetresc(){
  rotate([-10,0,0])translate([0.2,-0.5,2])cube([4.1,0.6,2]); 
};
//fenetresc();

module arrondi(){
    translate([-0.2,0,4.4])rotate([0,-45,0])cube([1,16,1]);
    translate([4,0,5.1])rotate([0,45,0])cube([1,16,1]);
    translate([-1,0,-0.2])rotate([0,45,0])cube([1,16,1]);
    translate([4.6,0,-1.1])rotate([0,-45,0])cube([1,16,1]);
};

module diff1(){
  difference(){
    rame2();
      porte();
      fenetresr();
      fenetresc();
      translate([4.5,14,0])rotate([0,0,180])fenetresc();
      arrondi();
  };  
};

//diff1();

module remplissage(){
difference(){
translate([0.1,2,1])cube([4.3,10,3.8]);
    fenetresp();
};
translate([0.2,2,1])cube([4.1,10,3.8]);
translate([0,4.6,2.4])cube([4.5,5.1,1.2]);
translate([0.1,1.2,2.2])cube([4.3,0.5,1.2]);
translate([0.1,12.2,2.2])cube([4.3,0.5,1.2]);
};
//remplissage();

module train(){
    diff1();
    remplissage();
};
//train();