Skip to main content

Groupe B2

Nom des participants :

  • Axelle Mano
  • Vangu Nlandu Vangu
  • Clémence Pereira
  • Ibtyssam Seddiki 

Groupe : CMI Physique B

Journal de bord : 

Séance 1 - 29/01/2024

Pour cette première séance de l’UE LU1SXPFL, nous avons commencé par une présentation de l’origine et du fonctionnement du Fablab mais aussi de l’objectif final de ce cours. Nous devrons donc documenter notre avancée sur le projet final à rendre et présenter en fin de semestre. Les valeurs fondamentales du Fablab sont le partage, l’ouverture et l’interdisciplinarité. Nous avons visionné un cours de la fabacademy enseigné par Neil Gershenfeld, créateur du créateur du Fablab et du cours How to make (almost) anything. Nous avons également rencontré l’équipe des Fabmanagers.

Ensuite, nous avons visité le FabLab en commençant par la salle des imprimantes 3D. Nous avons pu y observer différents objets qui ont été imprimés avec ces imprimantes et tout le matériel utilisé. 

Salle d’impression 3D

Imprimante 3D

Après la salle d’impression 3D, nous avons visité la salle de découpe, dans laquelle nous avons pu découvrir des machines qui utilisaient différentes méthodes de découpe précises :  laser, jet d’eau, fil chaud, etc. 

 

                                                             Salle de découpe

Découpeuse à jet d'eau

Puis nous nous sommes rendus dans la salle d’électronique, où se trouvent les appareils à soudure et le matériel de protection (gants, masques, casques). 

Salle d'électronique Nous avons visité la salle de préproduction dans laquelle nous avons  découvert la fraiseuse. Puis nous avons eu accès à la salle de menuiserie dans laquelle nous avons découvert la fraiseuse à bois.

Troisièmement et dernièrement, nous avons formé nos groupes, Vincent Dupuis nous a présenté comment documenter notre Wiki et donc nous avons commencé notre documentation sur la première séance du projet FabLab. 

Séance 2 - 05/02/2024

Lors de cette seconde séance nous avons été initié au design 2D, 3D, à l’impression 3D et à la découpe laser.

Premièrement, nous avons découvert Inkscape, un logiciel qui permet de dessiner les modèles 2D que nous voulons obtenir à la découpeuse laser. Nous avons découvert les fonctionnalités du logiciel, par exemple les différentes couleurs à utiliser en fonction de si on veut graver ou découper le matériau, et puis nous les avons explorées et testées en dessinant un modèle précis indiqué par monsieur Dupuis composé d’un rectangle et de 4 cercles situés à une distance précise des cotés du rectangle. Il a donc fallut calculer et régler les positions de chaque objet afin d’obtenir ce dessin :

Capture d’écran 2024-02-05 095008.png

Ensuite, nous avons découvert OpenSCAD, un logiciel de modélisation pour les imprimantes 3D. Nous avons aussi pris en main le logiciel en explorant un maximum de ses fonctionnalités, notamment le codage. En effet, il faut utiliser un langage de code spécifique pour exprimé ce que nous souhaitons modéliser. Comme pour Inskape, notre professeur nous à donné un modèle à reproduire afin que l’on se familiarise avec le logiciel. Nous avons pu modéliser un cube avec des des trous sur chacune de ses faces. Aussi, nous avons découvert la « CheatSheet » d’OpenScad, page web sur laquelle est regroupé toutes les lignes de code et le langage à écrire pour modéliser.

Capture d’écran 2024-02-11 104110.png

Puis, nous avons découvert FreeCAD, un logiciel qui permet d’utiliser la modélisation volumique, la modélisation fonctionnelle, et la modélisation surfacique, trois types de modélisation entièrement paramétrables. Nous avons également pris en main le logiciel et explorer en modélisant un cube, puis en dessinant des cercles sur ses faces et en les extrudant, on obtenait des cylindres à l’intérieur du cube. Il suffisait de soustraire les cylindres au cube pour avoir un cube troué similaire à celui réalisé sur OpenScad. Cependant, nous avons pu voir que ce logiciel n’était pas le meilleur pour la modélisation 3D car pas très intuitif à l’utilisation.

Capture d’écran 2024-02-11 110427.png

Enfin, en fin de séance, une Fabmanager nous a monter en détails comment faire une impression 3D en nous montrant comment utiliser les imprimantes, et aussi comment faire de la gravure et de la découpe laser. Nous avons ainsi été informés de toutes les étapes à réaliser avant de laisser une imprimante 3D ou une découpeuse laser, comme régler les paramètres de structure interne ou la présence de support pour une impression 3D et le réglage de la focale pour la découpeuse laser qui est automatique sur certaines machines. Nous nous avons également été avertis des précautions à prendre afin d’avoir une utilisation responsable des machines mises à notre disposition mais aussi pour notre sécurité.

Séance 3 - 12/02/2024

Cette troisième séance a été une initiation au prototypage électronique avec l’aide d’arduino.
L’Arduino UNO est une plateforme électronique de prototypage rapide qui offre la possibilité de connecter facilement des capteurs en tant qu’entrées et des actionneurs en tant que sorties. Elle intègre divers composants électroniques, dont un élément central, un microcontrôleur capable de stocker et d’exécuter des programmes informatiques.
L’arduino permet des tests rapides de prototypes d’appareils électroniques.

La première étape est de créer un programme dans un environnement de développement (Integrated Development Environment), c’est-à-dire une application sur laquelle on code. L’ide Arduino permet de créer du code puis de compiler ce code en un fichier compréhensible par le microcontrôleur (langage binaire) en le téléversant. Le language utilisé est le C. Il existe trois parties essentielles à un programme :

  • commence par include → permet d’inclure du code dans le code/réutiliser du code déjà existant, les fonctions associées au capteur sont empaquetées dans une bibliothèque et pour parler avec le capteur il faut inclure du code externe
  • fonction setup → permet d’initialiser le code et il sera exécuté 1 seule fois
  • fonction loop → exécute une action en boucle 

Blink.ino sur arduino est équivalent au Hello world utilisé dans les autres langages informatiques tels que Python pour démontrer leur fonctionnement de manière simple et rapide.

Après cette introduction théorique sur le fonctionnement d’Arduino, nous nous sommes mis en binômes afin de faire une première prise en mains d’un capteur. Le premier exercice consistait à brancher une LED rouge et une résistance en série et de télécharger un programme disponible dans la base de donnée de l’ide Arduino pour faire clignoter la LED (allumée 1 seconde, éteinte 1 seconde). En connectant la Breadboard, l’Arduino Uno et l’ordinateur nous avons téléversé le programme afin qu’il soit exécuté :

 20240212_100630.jpg

20240212_100631.jpg

Le programme utilisé était un des exemples dans les programmes basiquesde l’IDE et s’appelait « Blink » :

void setup() {
pinMode(LED_BUILTIN, SORTIE) ;
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);  
  delay(1000);                      
  digitalWrite(LED_BUILTIN, LOW);   
  delay(1000);                      
}

Puis nous avons réalisé un deuxième circuit comportant un capteur d'humidité et de température. Pour obtenir les informations voulues du capteur, nous avons téléchargé une bibliothèque disponible du site du fabriquant et nous l'avons  inclue dans l'IDE : 

A la fin de la séance, nous avons pu découvrir tous les capteurs disponibles pour notre projet final et réfléchir à ce que l'on voudrait faire. 
Séance 4 - 26/02/2024

Lors de cette quatrième séance, nous avons commencé notre projet de groupe.

L’objectif est concevoir un système usant d’au moins un détecteur/ capteur, d’effectuer une expérience physique avec et de réaliser une série de mesures.

 

Nous avons décidé de concevoir un détecteur d’intensité sonore. Le principe est de mesurer l’intensité et le volume sonore selon l’endroit et les matériaux présents dans ces endroits, mesurer l’atténuation de chaque matériau (verre, bois, plexiglas) et vérifier la loi physique sur le niveau d’intensité sonore : L = 10log(I/Io).

 

Pour nos premiers tests, nous avons eu besoin d’un capteur de son et d’une carte Arduino Uno.

 

Tout d’abord, nous avons tester le détecteur de son, soit le Grove - Sound Sensor :

 

 

Ainsi, nous avons dû calibrer le détecteur pour pouvoir tester ses fonctionnalités.

 

Nous avons utilisé un code qui permettait de prendre des mesures du niveau sonore, nous avons pris ce code sur :

https://sensorkit.arduino.cc/sensorkit/module/lessons/lesson/06-the-sound-sensor


int sound_sensor = A2 ; //assigner à la broche A2





Configuration du vide ()


{


Série.début(9600) ; //begin Communication série


}




Boucle du vide ()


{


int soundValue = 0 ; //create pour stocker de nombreuses lectures différentes


for (int i = 0 ; i < 32 ; i++) //crée une boucle for à lire


{ soundValue += analogRead(sound_sensor) ; } //lire le capteur de son




soundValue >>= 5 ; Opération //bitshift


Série.println(valeurduson) ; //affiche la valeur du capteur de son






Si une valeur supérieure à 500 est enregistrée, nous imprimerons ce qui suit


Ceci est fait pour que nous puissions voir clairement si le seuil est atteint


if (soundValue > 500) {


  Série.println( » || »);


  Série.println( » |||||| »);


  Série.println( » ||||||||| »);


  Série.println( » ||||||||||||| »);


  Série.println( » ||||||||||||||||| »);


  Série.println( » ||||||||||||| »);


  Série.println( » ||||||||| »);


  Série.println( » |||||| »);


  Série.println( » || »);


}


delay(50); //a shorter delay between readings


}

Observation d’un graphe de valeurs (unités des axes encore pas très claires pour nous : peut-être des Volts)

Cela nous confirme que notre capteur focntionne !

 

La prochaine étape est de réfléchir à comment modifier le code pour avoir des résultats en dB.

 

Objectifs pour les prochaines séances :


Il faut prendre un certain nombre de mesures (échantillonnage) à intervalle régulier (idée du forum : arduino decibel meter)


OU 


Faire un échantillonnage nous-même : on prend une mesure en envoyant une certaine valeur en dB ensuite on observe le signal en Volts que l’on reçoit, on trace une courbe sur Regressi pour avoir la fonction correspondante et donc pouvoir par la suite passer de Volt à dB. C’est une bonne piste pour la prise de mesure.


Puis pour tester l’atténuation on prendra différents matériaux et on voit si l’atténuation est linéaire/continue/autre et fonction des dB de la source. Il est nécessaire de connaître les caractéristiques des matériaux que l’on utilise.


Pour la source sonore, on prendra un bruit blanc (par exemple) qu’on trouve sur Youtube dont on connaît le niveau sonore, on mesurera son volume sonore avec Phyphox (sur un autre téléphone) et on le laissera le son en continu lors de notre expérience afin d’avoir un résultat cohérent. Pour utiliser Phyphox on procèdera à un étalonnage grâce à un sonomètre et une source afin de connaître la valeur précise du son pour avoir une valeur de référence.

On relèvera ensuite les sons selon les matériaux en comparant avec le son initial et on calculera l’atténuation sonore.

 

On répète la même expérience pour tous les matériaux. 

 

Pour vérifier nos résultats, on regardera sur internet les atténuations des différents matériaux afin d’avoir un ordre de grandeur pour nos mesures. Aussi, il faut qu’on choisisse des matériaux avec des valeurs d’atténuation assez différentes.

 

Enfin, il faut comparer nos mesures aux mesures connues et discuter de la fiabilité et de la précision de notre dispositif.

 

Idées de matériaux :

 

Verre 

BOIS

Chlorure de polyvinyle

LIÈGE

 

 

 

Séance 5 - 04/03/2024

Objectifs du jour : 


  • étalonner nos téléphones (Phyphox)  
  • prendre une première série de mesure 
  • faire une courbe sur Regressi : corrélation Volts et dB


Première étape : Étalonnage 

Nous avons étalonné Phyphox sur nos téléphones à l’aide d’un « bruit rose ». Nous avons ainsi mesuré 70 dB.

Expérience : Nous nous sommes installés dans la salle de réunion du FabLab car assez insonorisée et silencieuse. La source de son (téléphone de Clémence) était placée à 1m de nos téléphones, pour préserver l’étalonnage, nous avons enregistré le décalage (113 dB pour le téléphone utilisé lors des prises de mesures par la suite). 


Deuxième étape : Prise de mesure 

Une fois Phyphox étalonné, nous avons pris une série de valeurs à l’aide du capteur « Grove - Sound Sensor », cependant, les valeurs obtenues n’étaient malheureusement pas du tout cohérentes. En effet, en parallèle de la prise de mesure, nous avons ouvert Regressi afin de pouvoir tracer la courbe et donc pouvoir faire une corrélation entre Volts et dB. On s’attendait à ce que la corrélation soit à peu près linéaire, ou du moins cohérente, cependant ça n’a pas fonctionné.


Résultats : 

Troisième étape : changement de capteur


Nous avons ensuite changé de capteur en prenant le capteur d’intensité sonore. Par manque de temps, nous n’avons fait que très peu de mesures.


Programme utilisé pour le capteur « Grove - Loudness Sensor » :

int val ;

Configuration du vide ()

{

  Série.début(9600);

}


Boucle du vide ()

{

  analogRead(0);

  retard(10);

  val = analogRead(0);

  Série.println(val);

  retard(200);

}

Source : https://seeeddoc.github.io/Grove-Loudness_Sensor/


Mais les premières valeurs obtenues restaient quand même plus cohérentes, nous obtenons une droite linéaire.

Objectifs pour la prochaine séance : 


Pour la prochaine séance nous comptons donc faire le plus de mesures possibles avec ce capteur. L’objectif est aussi de faire varier la résistance qui est lié à la sensibilité du capteur. Ainsi on prendra les valeurs les plus cohérentes.

Il nous reste un dernier capteur à tester le grove Analog Microphone qui se rapproche plus du microphone présent sur nos téléphones. En testant ce dernier capteur nous pourrons ainsi choisir avec lequel parmi les 3 nous obtenons les valeurs les plus cohérentes, pour avoir la meilleure fonction reliant Volts et dB. 

Nous essaierons également de prendre des mesures avec différents matériaux situés entre la source et le capteur afin de pouvoir calculer un rapport qui représenterait l'atténuation du matériau et voir si on obtient des valeurs cohérentes.


Grove- Analog Microphone

Grove microphone.png analogique

Nous essaierons également de prendre des mesures avec différents matériaux situés entre la source et le capteur afin de pouvoir calculer un rapport qui représenterait l’atténuation du matériau et voir si on obtient des valeurs cohérentes.

Séance 6 - 11/03/2024

Après plusieurs essais, nous nous sommes rendues compte que phyphox posait un problème et avons donc utilisé une autre application de mesure sonore : sound meter.

Nous avons testé un microphone analogique :

hardware_connection.jpg

Avec le code suivant :

/*
Entrée analogique, sortie analogique, sortie série

Lit une broche d’entrée analogique, mappe le résultat sur une plage comprise entre 0 et 255 et utilise
le résultat pour définir la modulation de largeur d’impulsion (PWM) d’une broche de sortie.
Imprime également les résultats sur le moniteur série.
*/

Ces constantes ne changeront pas. Ils sont utilisés pour donner des noms aux broches utilisées :
const int analogInPin = A0 ; Broche d’entrée analogique à laquelle le potentiomètre est attaché const
int analogOutPin = 9 ; Broche de sortie analogique à laquelle la LED est fixée

int sensorValue = 0 ; valeur lue à partir du pot
int outputValue = 0 ; sortie de valeur vers le PWM (sortie analogique)

void setup() {
Serial.begin(9600) ; // initialise les communications série à 9600 bps
}

void loop() {
sensorValue = analogRead(analogInPin) ; // lit la valeur
de l’entrée analogique outputValue = map(sensorValue, 0, 1023, 0, 255) ; // la mappe à la plage de la sortie
analogique analogWrite(analogOutPin, outputValue) ; // change la valeur de la sortie analogique

Serial.println(outputValue) ; imprimer les résultats sur le moniteur série

attendre 2 millisecondes avant la boucle suivante pour que le convertisseur // analogique-numérique
se stabilise après la dernière lecture :
delay(2) ;
}

Trouvé sur ce site : https://wiki.seeedstudio.com/Grove-Analog-Microphone/

décibels
bits (0 à 1023)
68 
327 - 300
64 
312 - 315
60 
300 - 301
55  294 - 295
Séance 7 - 18/03/2024

Pour cette 7ème séance, nous avons commencé par essayer de modifier le code de notre capteur afin d’obtenir les valeurs directement en décibels à partir du rapport que nous avions trouvé la semaine précédente. Cependant, nous nous sommes rendus compte que cette conversion n’était pas forcément utile car notre expérience consiste à calculer un rapport entre le niveau d’intensité sonore de la source et celui perçu par le capteur après les matériaux. Ainsi, nous allons garder le code fourni par le constructeur du capteur.

Ensuite, nous avons voulu commencer à tester l’atténuation de certains matériaux et définissant des conditions expérimentales spécifiques qui nous permettraient d’avoir une meilleure précision et de pouvoir comparer les résultats entre eux. Nous avons donc scotché le capteur à plat sur une table, puis nous avons tracé deux traits à 20 et 40 centimètres du capteur. Au niveau du premier trait nous avons placé le matériau et sur le deuxième, la source (téléphone). Le bruit utilisé était une vidéo Youtube avec un bruit de 1 kHz à volume constant. Nous mesurions d’abord le niveau d’intensité sonore perçu par le capteur sans le matériau au milieu, puis en ajoutant le matériau afin de mesurer la différence. Cependant, nous avons rencontré des difficultés car les valeurs mesurées ne changeaient pas de manière significative et que les variations étaient plutôt aléatoires. Nous en sommes arrivés à trois conclusions :

  • la source n’est pas assez puissante et une grande partie du son est perdue dans l’environnement le capteur ne peut donc mesurer les différences de manière exacte
  • le capteur est directionnel en le mettant à plat, la meilleure manière de mesurer les variations de pressions est de mettre la source au dessus
  • pour comparer les niveaux d’intensité sonores, nous ne devons pas prendre les valeurs affichées, mais comparer les amplitudes

Pour palier aux deux premiers problèmes, nous avons créé un dispositif inspiré d’un appareil utilisé en TP que nous avons trouvé sur le site de Jeulin (https://jeulin.com/jeulin_fr/302328.html) :

Capture d’écran 2024-03-24 163917.png

L’objectif est donc d’utiliser un tube qui forcerait la propagation du son dans une direction et nous permettrait ainsi moins de pertes dans l’environnement mais aussi de l’orienter pour qu’il soit perçu correctement par le capteur. Nous avons trouvé un tube en carton don’t nous avons bouché une extrémité avec un cercle de polystyrène d’environ 3 centimètres d’épaisseur et nous avons percé un trou pour faire passer le capteur. De cette manière, le bout du tube est isolé et permet une meilleure mesure, de plus, le capteur est orienté vers l’autre extrémité du tube.

20240318_111703.jpg

Une autre amélioration que nous avons apportée au dispositif est que nous avons changé de source. Auparavant, nous utilisions notre téléphone qui n’est pas très puissant et le bruit venait de Youtube, nous ne pouvions pas vraiment être certains que le volume était parfaitement constant ni même que la fréquence était exacte. Notre professeur nous a fourni un haut parleur circulaire qui a un diamètre proche de celui du tube. Il nous a montré comment souder des fils au haut parleur afin de le connecter à un générateur de basses fréquences qui nous permettrait à la fois de choisir l’amplitude et la fréquence de l’onde.

IMG_9532.jpg

IMG_9531.jpg

Pendant le temps qui nous restait, nous avons effectué des mesures sans matériau à différentes fréquences et en ne prenant en compte que l’amplitude de l’onde donnée par la fonction Serial Plotter d’Arduino.

IMG_9533.jpg

Pour la prochaine séance, nous devrons trouver un moyen d’insérer des matériaux entre la source et le capteur. Pour l’instant nous avons deux options : soit nous allons faire une fente dans le tube pour glisser les matériaux dedans, cependant le matériau ne pourra boucher la totalité du diamètre du tube et nous devrions donc mettre un morceau de polystyrène dans la partie non couverte mais cela risque de perturber la mesure ; sinon nous pourrions utiliser un autre tube (ou couper celui que nous avons en deux) de cette manière toute la surface du tube serait remplie, mais il faudrait tenir les tubes et le matériau ou trouver un moyen de les faire tenir.

Enfin, nous allons essayer de trouver des matériaux d’épaisseurs proches afin que les mesures puissent être comparables entre elles.

Séance 8 -25/03/2024

Objectif de la séance : construire le vrai support qui nous permettra de tester les différents matériaux pour mesurer leur atténuation avec le capteur. 

Nous avons décidé de réaliser d’abord un prototype qui nous servirai de test pour voir ce qu’on pourrait améliorer sur le vrai support ( forme, distance ...)

Pour pouvoir insérer les matériaux, nous avons décidé de faire une fente dans un des tubes que nous avions à disposition. Le problème est qu’il fallait remplir la partie restante lorsqu’on insérait le matériaux car il était à bord plat et le tube circulaire. Nous avons donc découpé dans du carton une forme qui comblerait ce trou : mettre photo.

Nous avons ensuite collé la forme à l’extrémité d’un des tubes avec un pistolet à colle pour que ce soit plus solide. Puis nous avons comblé les petits trous qu’ils restaient avec la colle pour être sur qu’aucuns sons ne passent.

Pour la fente, nous avons opté pour le système suivant : 

  • un morceau de carton bouchera le bas du cylindre 

  • on découpera le cylindre jusqu’au morceaux de carton afin qu’on est pas besoin de boucher les côtés du cylindre étant donné que notre morceau de matériau aura une forme rectangulaire

  • ainsi, on aura juste à faire glisser le matériau jusqu’à la fente pour prendre nos mesures

Nous avons ensuite découper notre fente à l’aide d’une scie.

Capture d’écran 2024-03-29 161516.png

Une fois notre prototype prêt, nous avons testé des matériaux trouvés au fablab en prenant une longueur du tube deux fois plus grande que sur le prototype final. Nous avons relevé les valeurs suivantes :

Capture d’écran 2024-03-29 162644.png

Les valeurs obtenues nous semblent cohérentes donc nous avons décidé de passer au vrai prototype. Cependant, il faut noter que nous avons pris des références trouvées sur internet qui dépendent de beaucoup de facteurs. Avec le temps qu’il rester, nous avons réussi à découper la forme finale qui sera à coller et à couper la fente dans notre tube.

Pour la prochaine et dernière séance, il nous restera donc à tester notre prototype final.

Séance 9 - 22/04/2024

Nous avons consacré cette dernière séance au test de notre capteur avec 8 matériaux d'absorbance variable. Nous avons réalisé ces tests à 1kHz car il s'agit de la valeur de référence pour les mesures en acoustique et qu'il fallait que l'on choisisse une fréquence pour fixer les conditions expérimentales et pouvoir comparer les résultats à la fin. 

En début de séance, nous avons finalisé notre prototype. Il ne restait plus qu'à redécouper légèrement la fente à la scie après avoir coller le morceau de carton qui sert pour combler le vide lorsque l'on insert une plaque de matériau. 

Ensuite, nous nous sommes mis au mesures. 

Nous avions une multitude de matériaux à notre disposition, d'épaisseurs différentes grâce à notre camarades Clémence. 

Nous avons tout d'abord commencé par les matériaux de "petites" épaisseurs, qui rentrent dans notre fente. 

Pour faire tous nos test nous avons appliqué une fréquence 1kH à l'aide du générateur basse fréquence et nous avons fais de notre mieux pour reproduire, pour chaque mesure, exactement les mêmes conditions d'expériences afin d'avoir les résultats les plus précis possibles.

Par la suite, lorsque nous avons effectué nos tests pour des matériaux plus épais, nous avons élargie la fente afin que ceux-ci puisse rentrer au fur et à mesure.

Voici quelques images de nos prises de mesure : 

IMG_9690.jpg

IMG_9691.jpg

IMG_9693.jpg

IMG_9696.jpg

IMG_9692.jpg

IMG_9694.jpg

IMG_9695.jpg

Ainsi, pour chacun des matériaux, nous relevions l'épaisseur et l'amplitude. 

1) Pour les petites épaisseures : 

10 Vpp

1 KHz


Regupol 

Treppenlager SB10

Granit

Sans rien


fente ouverte 

Sans rien fente scotchée 

Epaisseur

5 mm

8 mm

8 mm

fente

fente

Amplitude 1

10

5

2X2

27

17

Amplitude 2

11

4

4

22X2

17

Amplitude 3

10

3

1X2

18

19

2) Pour les grosses épaisseurs : 

10 Volts

1000 Hz


A vide

fente ouverte

A vide scotchée

laine de bois

Bouteille en plastique recyclée

Plaque de plâtre 

Laine de coton recyclée

Mousse mélamine

Epaisseur

0 mm 

0 mm

15 mm

12 mm

12,5 mm

fente

fente

Amplitude 1

19

28

20

8

2

6

8x2

Amplitude 2

17X2

21X3

21X4

8

2

7

12x2

Amplitude 3

18

30

24

27X2

29

24

8

3

8x2

11

13

 

Pour chaque matériau, nous avons des séries de 3 mesures afin d'observer une possible récurrence des mêmes résultats.

On peut voir que pour la plupart des matériaux, les résultats sont très rapprochés et que pour d'autres les résultats varient légèrement. 

A présent, nous devons calculer les atténuations de chacun des matériaux afin de déterminer si cela correspond bien au registres des atténuations que nous possèdons. En effet, avec les matériaux, Clémence a pu obtenir une sorte de registre dans lequel l'atténuation de chaque matériau est répertoriée.

Matériau

Regupol

(caoutchouc)

Treppenlager

(plastique bulle)

Granit
Laine de bois
Plastique recyclé
Plâtre
Laine de coton
Mousse mélamine
Épaisseur (mm)
5
8
8
15
12
12,5
fente
fente
Atténuation
0,58
0,23
0,15
0,94
0,33
0,1
0,3
 0,44

Ainsi, les mesures semblent plutôt cohérentes car pour les matériaux les plus denses et épais et donc les plus absorbants, le coefficient est faible et inversement pour les moins épais et moins denses.

On peut dire que notre disposition fonctionne plutôt bien. Bien sûr il n'est parfais car pas très précis, aussi lors des prises de mesures il faut tenir le haut-parleur à chaque fois ce qui n'est pas très pratique et la fente n'est pas modifiable. En effet, on a du épaissir la fente pour les matériaux plus épais donc il n'est plus possible de refaire des  mesures avec les matériaux les moins épais.

 

 

 


Projets personnels
Axelle

I/ Impression 3D 

Objectif : faire une règle de 15 cm environ avec des motifs à l’intérieur qui rentre dans ma trousse.

J’ai d’abord décidé de me concentrer sur les motifs de la règle (règle pour enfant qui sert a dessiner plusieurs choses comme des fleurs des maisons ou des coeurs). Je ferais donc à la fin les graduations.

Première étape : la règle 

J’ai donc commencé par faire un rectangle basique avec le code pour créer un cube que j’ai adaptée de sorte à faire un rectangle qui a une petite épaisseur comme une règle

     cube([4,20,0.25],true);

Deuxième étape : les motifs 

Pour réaliser les motifs, j’ai utilisé uniquement la fonction « différence » .

Premier motif : le coeur

J’ai d’abord décidé de faire un coeur. Pour cela, j’ai créé deux cylindres que j’ai positionné a des coordonnées différentes de sortes a formé la partie haute du coeur. Pour la partie basse du coeur, J’ai utilisé un cube tourné à 45 degrés et j’ai utilisé la fonction Union.

 

translate([0,-7.5,0])
  rotate([0,0,45])   
   cube([1.5,1.5,1.5],true);
     
    union(){    
     translate([-0.5,-7,-1]) cylinder(h=1.5,d=1.5,$fn=50);
      translate ([-0.5,-8,-1]) cylinder(h=1.5,d=1.5,$fn=50);
    };

 

Capture d’écran 2024-03-28 231609.png                                               

 

Deuxième motif : l’idée m’est venue en travaillant mes cours d’électronique numérique. Sachant que nous devons dessiné beaucoup de portes logiques, j’ai décidé de représenter les principales, c’est à dire les portes AND et OR. Pour la porte And, la plus simple, j’ai commencé par faire une sorte d’ellipse que j’ai rempli avec un cube. Je pense qu’il y avait plus simple, mais je n’ai pas réussi à faire un demi-cercle directement. Puis j’ai rajouté un texte « AND » en faisant la différence avec le cube. J’ai fait exactement le même procédé pour ma porte OR, mais au lieu de remplir avec un carré, je l’ai rempli avec une autre ellipse qui était moins « courbée ». J’ai aussi écris un texte « OR » à côté de ma porte de la même manière, Comme ce sont des volumes, mes formes dépassaient j’ai donc soustrait un cube juste au dessus de ma règle. J’ai obtenu le résultat suivant don’t je suis très satisfaite :

Capture d’écran 2024-04-18 205425.png     

 translate([0,7.5,0])
 scale([1.75,2.5])sphere(r=0.5,$fn=50);
   translate ([0,3.7,0])
     scale([1.75,2.5])sphere(r=0.5,$fn=50);
   r(n=10, id=30, d=50);

C’est le code correspondant aux ellipses de bases

translate([-0.25,3.2,-0.1])
cube([0.1,0.4,0.2]);

translate([0.05,3.2,-0.1])
cube([0.1,0.3,0.2]);

translate([0.3,7,-0.1])
cube([0.08,0.4,0.2 ]);

Code pour relier les lettres comme le O le R ou le D car elles tomberaient sans

difference(){
 translate([-1,5.5,-0.125])
 cube([2,2,0.25]);
     translate([-0.45,7,-0.5])        
  linear_extrude(4)
    text("AND", size=0.35); 
 };

difference(){
    translate ([0,3,0])
     scale([2,2.25,0.5])sphere(r=0.5,$fn=50);
   translate([-0.4,3.25,-0.5])
    linear_extrude(4)
    text("OR", size=0.35);
    translate([0,0,0.26])   
 cube([4,20,0.25],true);
    translate([0,0,-0.26])   
 cube([4,20,0.25],true);
};

Code pour « AND » « OR » et les cubes qui servent à enlever le haut des ellipses

Motif suivant : soleil 

J’ai réfléchi à différentes manières de faire mon soleil. J’ai choisi la plus simple, c’est à dire un rond et des traits autour. J’ai donc faire mon cercle sans difficulté puis j’ai commencé à faire mes traits. J’ai commencé par les plus simples soit ceux aux angles de 0 ,90, 180 et 270 degrés. J’ai donc utilisé la fonction translate et j’ai changé les dimensions de mon cube pour les traits de côté.

Pour les traits situé sur les « diagonales », j’ai utilisé la fonction rotate en tournant à chaque fois mon trait de 90 degrés.

J’ai eu beaucoup de difficulté avec la fonctions traduites car après avec tourner mes traits à 90 degrés lorsque je voulais déplacer sur les x mon trait, il bougeait sur un autre axe. Mais je suis tout de même parvenue à un résultat satisfaisant en tatonnant et en raisonnant avec logique.

translate([0,-3,-1])
  cylinder(h=2,r=0.5,$fn=50); 
     
    translate([0,-4.25,-0.5])
     cube([0.1,0.5,2]);
    translate([0,-2.25,-0.5])
     cube([0.1,0.5,2]);
 
    translate([-1.25,-3,-0.5])
     cube([0.5,0.1,2]);
    translate([0.75,-3,-0.5])
     cube([0.5,0.1,2]);
     
    rotate([0,0,45])
    translate([-1.3,-2.25,-0.5])
     cube([0.5,0.1,1]);
    
    rotate([0,0,135])
    translate ([-1.25,2,-0.5])
     cube([0.5,0.1,1]);
     
    rotate([0,0,225])
    translate ([2.95,2,-0.5])
     cube([0.5,0.1,1]);
    
    rotate([0,0,315])
    translate ([2.95,-2.1,-0.5])
     cube([0.5,0.1,1]);

 

                                                            Capture d’écran 2024-03-29 172017.png

Dernier élément : j’ai décidé d’ajouter mon prénom « AXELLE » au milieu de ma règle car je n’avais plus d’idée. J’ai donc repris le même code que pour le AND et OR en ajoutant un rotate de 90 degrés.

Capture d’écran 2024-03-29 172315.png

J’ai donc fini la partie motif de ma règle. Voici le code complet


 
 difference(){
     
cube([4,20,0.25],true);
   
 translate([0,-7.5,0])
  rotate([0,0,45])   
   cube([1.5,1.5,1.5],true);  
   union(){    
     translate([-0.5,-7,-1]) cylinder(h=1.5,d=1.5,$fn=50);
      translate ([-0.5,-8,-1]) cylinder(h=1.5,d=1.5,$fn=50);
    };
  
    translate([0,-7.4,0])
   rotate ([0,0,45]) 
     cube([1,1,1],true);
     
   translate([0,7.5,0])
 scale([1.75,2.5])sphere(r=0.5,$fn=50);
   translate ([0,3.7,0])
     scale([1.75,2.5])sphere(r=0.5,$fn=50);
   r(n=10, id=30, d=50);
     
     
    translate([0,-3,-1])
  cylinder(h=2,r=0.5,$fn=50); 
     
    translate([0,-4.25,-0.5])
     cube([0.1,0.5,2]);
    translate([0,-2.25,-0.5])
     cube([0.1,0.5,2]);
 
    translate([-1.25,-3,-0.5])
     cube([0.5,0.1,2]);
    translate([0.75,-3,-0.5])
     cube([0.5,0.1,2]);
     
    rotate([0,0,45])
    translate([-1.3,-2.25,-0.5])
     cube([0.5,0.1,1]);
    
    rotate([0,0,135])
    translate ([-1.25,2,-0.5])
     cube([0.5,0.1,1]);
     
    rotate([0,0,225])
    translate ([2.95,2,-0.5])
     cube([0.5,0.1,1]);
    
    rotate([0,0,315])
    translate ([2.95,-2.1,-0.5])
     cube([0.5,0.1,1]);
     
    rotate([0,0,90])
    translate([-1,0,-0.5]) 
     linear_extrude(4)
      text("A X E L L E", size=0.40);
     
};

 difference(){
 translate([-1,5.5,-0.125])
 cube([2,2,0.25]);
     translate([-0.45,7,-0.5])        
  linear_extrude(4)
    text("AND", size=0.35); 
 };

difference(){
    translate ([0,3,0])
     scale([2,2.25,0.5])sphere(r=0.5,$fn=50);
   translate([-0.4,3.25,-0.5])
    linear_extrude(4)
    text("OR", size=0.35);
    translate([0,0,0.26])   
 cube([4,20,0.25],true);
    translate([0,0,-0.26])   
 cube([4,20,0.25],true);
};


translate([-0.25,3.2,-0.1])
cube([0.1,0.4,0.2]);

translate([0.05,3.2,-0.1])
cube([0.1,0.3,0.2]);

translate([0.3,7,-0.1])
cube([0.08,0.4,0.2 ]);

Capture d'écran 2024-03-29 172945.png

Concernant les graduations, j'ai décidé de ne pas les faire et de rester sur l'objectif premier d'une règle c'est à dire tracer des traits droits.

L'impression c'est très bien déroulé, elle a duré 19 min j'ai choisis du fil type PLA 0,5mm gris. Voici le résultat :

IMG_0585 (1).jpg


II/ 2D 

J'ai choisis quelque chose de simple pour mon projet personnel de 2D et de prendre une image et de la vectoriser.

téléchargement (4).jpeg

Après avoir vectorisé, j’ai ensuite adapté la luminosité pour que les détails apparaissent bien

J'ai choisis comme matériaux du cp peuplier 3mm. 

IMG_0410.jpeg

J’ai obtenu le résultat suivant sans rencontré de problème lors de la gravure.

Vangu

 

Projet 2D

J'ai choisi de graver une page de mon manga préférée One Punch Man:

Pour cela j'ai téléchargé la page en question:

image.png

J'ai ensuite utilisé le logiciel InkScape et vectorisé l'image:

image.png

Finale j'ai usé de la graveuse:

20240422_094258.jpg

 

20240422_093108.jpg

 J'ai atteint ce résultat:

20240429_091213.jpg

 

Projet 3D

Gantelet articulé :

Commencé par un doigt :

On a la base, sans les articulations donc les parties qui vont recouvrir le doigt. 

Cette base a été faite en prenant les dimensions de mon majeur. Le reste de la main est un ratio à partir de cette partie.

Voici le code :

base du module ( ) { difference( ){

cube( [ 22,  22, 90] ) ;

traduire( [1, 1, -2] ){cube( [20, 20, 88] ) ;}

traduire( [-1, -2, 10] ){cube( [30, 30, 12] ) ;}

traduire( [-1, -1, 52] ){cube( [30,30,12] ) ;}}}


J’ai choisi une forme cylindrique plutôt que cubique pour des raisons purement esthétiques.


Voici où le plus gros problème commence, les joints. Pour que la main puisse bouger à l’intérieur, je devais mettre en place des articulations fonctionnelles se trouvant à l’extérieur de la main.

Les articulations sont constituées de deux parties principale :


Celles du côté du dos de la main

jav() ;

Celles du côté de la paume

jar() ;

module jav(){

difference(){

union(){translate([21.5,19.5,-10]){cube([1,2,26]) ;}

traduire([20,19.5,-25]){cube([1,2,20]) ;}

traduire([-0.5,19.5,-10]){cube([1,2,27.5]) ;}

traduire([1,19.5,-25]){cube([1,2,20]) ;}

traduire([22.8,0,16.5]){cube([0.2,2,2]) ;}

traduire([-1,0,16.5]){cube([0.2,2,2]) ;}

traduire([20,19.5,14]){cube([1,2,45]) ;}

traduire([1,19.5,14]){cube([1,2,45]) ;}

traduire([21.5,19.5,55]){cube([1,2,20]) ;}

traduire([-0.5,19.5,55]){cube([1,2,20]) ;}}


translate([-2,20.5,-9]){ rotate([0,90,0])

{cylindre(25,0.9,0.9) ;}}

translate([-2,20.5,15]){ rotate([0,90,0])

{cylindre(25,0.9,0.9) ;}}

translate([-2,20.5,57.5]){ rotate([0,90,0])

{cylindre(25,0.9,0.9) ;}}}



traduire([-1,20.5,-9]){rotate([0,90,0])

{cylinder(24,0.5,0.5);}}

translate([-1,19.5,-10]){cube([0.2,2,2]);}

translate([22.8,19.5,-10]){cube([0.2,2,2]);}


translate([-1,20.5,15]){rotate([0,90,0])

{cylinder(24,0.5,0.5);}}

translate([-1,19.5,14]){cube([0.2,2,2]);}

translate([22.8,19.5,14]){cube([0.2,2,2]);}


translate([-1,20.5,57.5]){rotate([0,90,0])

{cylinder(24,0.5,0.5);}}

translate([-1,19.5,56.5]){cube([0.2,2,2]);}

translate([22.8,19.5,56.5]){cube([0.2,2,2]);}}

module jar(){

{différence(){

union(){translate([-0.5,0,-20]){cube([1,2,40]) ;}

traduire([1,0,-30]){cube([1,2,15]) ;}

traduire([21.5,0,-20]){cube([1,2,40]) ;}

traduire([20,0,-30]){cube([1,2,15]) ;}

traduire([0.6,0,15]){cube([1,2,47]) ;}

traduire([20.4,0,15]){cube([1,2,47]) ;}

translate([-0.5,0,59]){cube([1,2,20]) ;}

traduire([21.5,0,59]){cube([1,2,20]) ;}}


translate([-1,1,-17.5]){rotate([0,90,0])

{cylindre(25,0.9,0.9) ;}} ;

translate([-2,1,18]){rotate([0,90,0])

{cylindre(25,0.9,0.9) ;}}

translate([-2,1,18]){rotate([0,90,0])

{cylindre(25,0.9,0.9) ;}}

translate([-2,1,60]){rotate([0,90,0])

{cylindre(25,0.9,0.9) ;}}}


translate([-2,1,60]){rotate([0,90,0])

{cylindre(25,0.5,0.5) ;}}

translate([-1,1,-17.5]){rotate([0,90,0])

{cylinder(24,0.5,0.5);}}

translate([-1,0,-18.5]){cube([0.2,2,2]);}

translate([22.8,0,-18.5]){cube([0.2,2,2]);}

translate([-2,0.5,17.5]){rotate([0,90,0])

{cylinder(25,0.5,0.5);}}

translate([22.8,0,16.5]){cube([0.2,2,2]);}

translate([-1,0,16.5]){cube([0.2,2,2]);}

translate([23,0,59.5]){cube([0.2,2,2]);}

translate([-1,0,59.5]){cube([0.2,2,2]);}}}


Les deux sont très similaires. La différence est dans leurs longueurs respectives pour permettre un déplacement d’un côté mais pas de l’autre.  

Relier les bases sans les paralyser:

-barres d’extension


Les barres sont directement implantées dans une base et mises en parallèle. Elles sont assez proches et ont un trou pour permettre à un cylindre d’y passer afin qu’il serve d’axe de rotation. 

Les cubes sont présents pour empêcher le cylindre de sortir.

translate([-2,1,60]){rotate([0,90,0])

{cylinder(25,0.5,0.5);}}

translate([-1,1,-17.5]){rotate([0,90,0])

{cylinder(24,0.5,0.5);}}

translate([-1,0,-18.5]){cube([0.2,2,2]);}

translate([22.8,0,-18.5]){cube([0.2,2,2]);}

translate([-2,0.5,17.5]){rotate([0,90,0]){cylinder(25,0.5,0.5);}}

translate([22.8,0,16.5]){cube([0.2,2,2]);}

translate([-1,0,16.5]){cube([0.2,2,2]);}

translate([23,0,59.5]){cube([0.2,2,2]);}

translate([-1,0,59.5]){cube([0.2,2,2]);}

Pour le reste des doigts j’ai utilisé la fonction scale à partir du majeur pour les créer.

module doigt(){base();jar();jav();}

La paume est tout simplement un cube vidé, assez grand.

module main(){translate([0,100,0]){rotate([-90,0,0]){

translate([0,0,2]){doigt();}  

translate([-50,0,0]){scale([1,1,6/9]){doigt();}}

translate([-25,0,0]){scale([1,1,8/9]){doigt();}}

translate([25,0,0]){scale([1,1,7.5/9]){doigt();}}

difference(){

translate([-52,0,-124.5]){cube([104,22,108]);}

translate([-50,2,-125.5]){cube([100,18,112]);}

translate([40,1,-100]){cube([20,20,30]);}}}}

translate([60,0,0]){rotate([0,90,0]){scale([1,1.5,0.6]){doigt();}}}}

J’ai ensuite customisé un peu pour mettre les pierre d’infinité un jour:

module hole(){cube([20,20,10]);}

module fini(){difference(){main();

translate([-15,0,-5]){cube([30,30,10]);}

translate([-50,55,-5]){hole();}

translate([-25,55,-5]){hole();}

translate([0,55,-5]){hole();}

translate([25,55,-5]){hole();}

translate([30,7.5,-5]){hole();}}}

Le code en entier donne:

module base(){difference(){

cube([22,22,90]);

translate([1,1,-2]){cube([20,20,88]);}

translate([-1,-2,10]){cube([30,30,12]);}

translate([-1,-1,52]){cube([30,30,12]);}}}


module jar(){

{difference(){

union(){translate([-0.5,0,-20]){cube([1,2,40]);}

translate([1,0,-30]){cube([1,2,15]);}

translate([21.5,0,-20]){cube([1,2,40]);}

translate([20,0,-30]){cube([1,2,15]);}

translate([0.6,0,15]){cube([1,2,47]);}

translate([20.4,0,15]){cube([1,2,47]);}

translate([-0.5,0,59]){cube([1,2,20]);}

translate([21.5,0,59]){cube([1,2,20]);}}


translate([-1,1,-17.5]){rotate([0,90,0])

{cylinder(25,0.9,0.9);}};

translate([-2,1,18]){rotate([0,90,0])

{cylinder(25,0.9,0.9);}}

translate([-2,1,18]){rotate([0,90,0])

{cylinder(25,0.9,0.9);}}

translate([-2,1,60]){rotate([0,90,0])

{cylinder(25,0.9,0.9);}}}


translate([-2,1,60]){rotate([0,90,0])

{cylinder(25,0.5,0.5);}}

translate([-1,1,-17.5]){rotate([0,90,0])

{cylinder(24,0.5,0.5);}}

translate([-1,0,-18.5]){cube([0.2,2,2]);}

translate([22.8,0,-18.5]){cube([0.2,2,2]);}

translate([-2,0.5,17.5]){rotate([0,90,0])

{cylinder(25,0.5,0.5);}}

translate([22.8,0,16.5]){cube([0.2,2,2]);}

translate([-1,0,16.5]){cube([0.2,2,2]);}

translate([23,0,59.5]){cube([0.2,2,2]);}

translate([-1,0,59.5]){cube([0.2,2,2]);}}}


module jav(){

différence(){

union(){translate([21.5,19.5,-10]){cube([1,2,26]);}

translate([20,19.5,-25]){cube([1,2,20]);}

translate([-0.5,19.5,-10]){cube([1,2,27.5]);}

translate([1,19.5,-25]){cube([1,2,20]);}

translate([22.8,0,16.5]){cube([0.2,2,2]);}

translate([-1,0,16.5]){cube([0.2,2,2]);}

translate([20,19.5,14]){cube([1,2,45]);}

translate([1,19.5,14]){cube([1,2,45]);}

translate([21.5,19.5,55]){cube([1,2,20]);}

translate([-0.5,19.5,55]){cube([1,2,20]);}}


translate([-2,20.5,-9]){ rotate([0,90,0])

{cylinder(25,0.9,0.9);}}

translate([-2,20.5,15]){ rotate([0,90,0])

{cylinder(25,0.9,0.9);}}

translate([-2,20.5,57.5]){ rotate([0,90,0])

{cylinder(25,0.9,0.9);}}}



translate([-1,20.5,-9]){rotate([0,90,0])

{cylinder(24,0.5,0.5);}}

translate([-1,19.5,-10]){cube([0.2,2,2]);}

translate([22.8,19.5,-10]){cube([0.2,2,2]);}


translate([-1,20.5,15]){rotate([0,90,0])

{cylinder(24,0.5,0.5);}}

translate([-1,19.5,14]){cube([0.2,2,2]);}

translate([22.8,19.5,14]){cube([0.2,2,2]);}


translate([-1,20.5,57.5]){rotate([0,90,0])

{cylinder(24,0.5,0.5);}}

translate([-1,19.5,56.5]){cube([0.2,2,2]);}

translate([22.8,19.5,56.5]){cube([0.2,2,2]);}}


module doigt(){

base();

jar();

jav();}


module main(){translate([0,100,0]){rotate([-90,0,0]){

translate([0,0,2]){doigt();}  

translate([-50,0,0]){scale([1,1,6/9]){doigt();}}

translate([-25,0,0]){scale([1,1,8/9]){doigt();}}

translate([25,0,0]){scale([1,1,7.5/9]){doigt();}}

difference(){

translate([-52,0,-124.5]){cube([104,22,108]);}

translate([-50,2,-125.5]){cube([100,18,112]);}

translate([40,1,-100]){cube([20,20,30]);}}}}

translate([60,0,0]){rotate([0,90,0]){scale([1,1.5,0.6]){doigt();}}}}


module hole(){cube([20,20,10]);}

module fini(){

difference(){

main();

translate([-15,0,-5]){cube([30,30,10]);}


translate([-50,55,-5]){hole();}

translate([-25,55,-5]){hole();}

translate([0,55,-5]){hole();}

translate([25,55,-5]){hole();}

translate([30,7.5,-5]){hole();}}}


fini();



La forme générale est respectée mais le résultat reste un échec. Les joints n’ont pas été correctement imprimés. Il aurait fallu les faire plus gros et plus espacés pour réduire l’importance de l’imprécision de la machine. 

De plus, les supports sont placés de telle sorte qu’il soit quasi impossible de les retirer.

Une bonne solution au problème de faire en sorte que les parties du gantelet puissent être imprimés séparément pour l’assembler.

 

Clémence
2D

Pour ma gravure, j’ai d’abord eu l’idée de créer un puzzle à 16 pièces avec un dessin assez simple dessus ((bien que je n’aie pas réussi à réaliser ce projet j’ai tout de même tenu à le documenter). J’ai utilisé Inkscape pour mon dessin et j’ai commencé par définir les contours de mon puzzle en traçant un carré de 200 pixels de côté. Puis j’ai dessiné une fleur en faisant un cercle (70 de rayon dont le centre est situé à équidistance de tous les côtés) pour le centre, puis huit ovales inclinés à différents angles pour les pétales. J’ai ensuite fait une union entre tous les pétales et une intersection entre le contour et les pétales pour qu’ils ne dépassent pas des bords du puzzle :



Capture d’écran 2024-03-29 171727.png

Je me suis ensuite lancée dans le tracé des lignes qui seraient découpées pour séparer les pièces. Cependant, j’ai rencontré des difficultés pour faire des lignes courbées au milieu de lignes droites. J’ai donc séparé les pièces en 16 carrés avec des lignes droites :

Capture d’écran 2024-03-29 171910.png

Mon objectif était de faire les formes qui permettraient aux pièces de s’emboiter puis de réaliser une opération pour le combiner à la ligne droite déjà tracée. Cependant, je n’ai pas réussi à trouver le bon moyen de parvenir au résultat que je recherchais je n’ai réussi qu’à faire des formes similaires aux bouts des puzzles mais pas à les combiner à une ligne. En effet, il reste toujours la ligne droite même à l’endroit du bout et si je le fait graver les parties supposées s’emboiter se détacheraient du reste du puzzle :

Capture d’écran 2024-03-29 172623.png

 Après cela je me suis arrêtée car je ne réussis pas à trouver de solution. 

J'ai ensuite appris qu'il était possible de prendre une image sur internet et de la vectoriser pour qu'elle puisse être lue et gravée par la découpeuse laser. J'ai choisi le logo de mon équipe de rugby préférée, l'Union Bordeaux-Bègles : 

image.png

(adresse de l'image : https://www.ubbrugby.com/application/uploads/idev_news/logo-ubb_380.png)

J'ai copié l'image sur Inkscape puis je l'ai vectorisée et j'ai réglé l'échelle de gris pour que les détails soit bien visibles à la gravure. Enfin, j'ai ajouté un cercle rouge autour pour que la machine découpe autour du logo. 

image.png

Voilà le résultat (il manque une petite partie sur la gauche car le morceau de bois que j'avais choisi était découpé sur le coté et que je l'ai placé sans prendre cela en compte) : 

image.png

3D

Pour la partie 3D du projet personnel, j’ai décidé de faire un champignon simplifié. je ne me suis pas inspirée d'une image en particulier car c'est plus difficile de reproduire un modèle mais dans l'idée je voulais que ça ressemble à une maison de Stroumpfs. J'ai donc commencé par réaliser le pied du champignon à l'aide de cylindres empilés de différentes tailles pour arrondir les bords au maximum. J'ai aussi du adapter la hauteur des cylindres entre eux afin qu'ils soient bien  les uns au dessus des autres. 

$fn=100;
//pied du champignon
translate([0,0,4]) cylinder(h=25,r1=14,r2=9);
translate([0,0,2]) cylinder(h=2,r1=14.5,r2=14);
cylinder(h=2,r1=15,r2=14.5);
translate([0,0,-1]) cylinder(h=1,r1=14.9,r2=15);
translate([0,0,-2]) cylinder(h=1,r1=14.7,r2=14.9);
translate([0,0,-3]) cylinder(h=1,r1=14.4,r2=14.7);
translate([0,0,-4]) cylinder(h=1,r1=14,r2=14.4);
translate([0,0,-5]) cylinder(h=1,r1=13.5,r2=14);
translate([0,0,-6]) cylinder(h=1,r1=12.9,r2=13.5);
translate([0,0,-7]) cylinder(h=1,r1=12.3,r2=12.9);
translate([0,0,-8]) cylinder(h=1,r1=11.5,r2=12.3);
translate([0,0,-9]) cylinder(h=1,r1=10,r2=11.5);
translate([0,0,-10]) cylinder(h=1,r1=8,r2=10);

image.png

J'ai ensuite ajouté le chapeau du champignon en utilisant la même méthodes d'empilement de cylindres mais en ajoutant une sphère au sommet pour que le haut soit bien arrondi et pas pointu.

//chapeau du champignon
translate([0,0,29]) cylinder(h=2,r1=30,r2=32);
translate([0,0,31]) cylinder(h=1,r1=32,r2=32.5);
translate([0,0,32]) cylinder(h=2,r1=32.5,r2=33);
translate([0,0,34]) cylinder(h=1,r1=33,r2=33);
translate([0,0,35]) cylinder(h=2,r1=33,r2=32.5);
translate([0,0,37]) cylinder(h=3,r1=32.5,r2=31);
translate([0,0,40]) cylinder(h=2,r1=31,r2=29.5);
translate([0,0,42]) cylinder(h=2,r1=29.5,r2=27);
translate([0,0,44]) cylinder(h=6,r1=27,r2=18);
translate([0,0,50]) cylinder(h=4,r1=18,r2=10);
translate([0,0,54]) cylinder(h=2,r1=10,r2=4);
translate([0,0,42.6]) sphere(r=14);

image.png

Enfin, j'ai décidé d'ajouter un motif sur le chapeau pour me rapprocher d'une maison de Stroumpfs. Pour cela j'ai fait des sphères et je les ai placées de manière à ce qu'elle sortent un petit peu du haut du champignon : 

//motif sur le champignon
translate ([26,0,37]) sphere(r=7);
translate ([13,-18,41]) sphere(r=7);
translate ([-16,-19,38.5]) sphere(r=7);
translate ([-25.8,10,35]) sphere(r=6);
translate ([5,11,47]) sphere(r=7);
translate ([-8,25,38]) sphere(r=6);

image.png

Mon code final et le rendu sur openscad sont : 

$fn=100;
//pied du champignon
translate([0,0,4]) cylinder(h=25,r1=14,r2=9);
translate([0,0,2]) cylinder(h=2,r1=14.5,r2=14);
cylinder(h=2,r1=15,r2=14.5);
translate([0,0,-1]) cylinder(h=1,r1=14.9,r2=15);
translate([0,0,-2]) cylinder(h=1,r1=14.7,r2=14.9);
translate([0,0,-3]) cylinder(h=1,r1=14.4,r2=14.7);
translate([0,0,-4]) cylinder(h=1,r1=14,r2=14.4);
translate([0,0,-5]) cylinder(h=1,r1=13.5,r2=14);
translate([0,0,-6]) cylinder(h=1,r1=12.9,r2=13.5);
translate([0,0,-7]) cylinder(h=1,r1=12.3,r2=12.9);
translate([0,0,-8]) cylinder(h=1,r1=11.5,r2=12.3);
translate([0,0,-9]) cylinder(h=1,r1=10,r2=11.5);
translate([0,0,-10]) cylinder(h=1,r1=8,r2=10);
//chapeau du champignon
translate([0,0,29]) cylinder(h=2,r1=30,r2=32);
translate([0,0,31]) cylinder(h=1,r1=32,r2=32.5);
translate([0,0,32]) cylinder(h=2,r1=32.5,r2=33);
translate([0,0,34]) cylinder(h=1,r1=33,r2=33);
translate([0,0,35]) cylinder(h=2,r1=33,r2=32.5);
translate([0,0,37]) cylinder(h=3,r1=32.5,r2=31);
translate([0,0,40]) cylinder(h=2,r1=31,r2=29.5);
translate([0,0,42]) cylinder(h=2,r1=29.5,r2=27);
translate([0,0,44]) cylinder(h=6,r1=27,r2=18);
translate([0,0,50]) cylinder(h=4,r1=18,r2=10);
translate([0,0,54]) cylinder(h=2,r1=10,r2=4);
translate([0,0,42.6]) sphere(r=14);
//motif sur le champignon
translate ([26,0,37]) sphere(r=7);
translate ([13,-18,41]) sphere(r=7);
translate ([-16,-19,38.5]) sphere(r=7);
translate ([-25.8,10,35]) sphere(r=6);
translate ([5,11,47]) sphere(r=7);
translate ([-8,25,38]) sphere(r=6);

image.png

Aperçu en mode "Render"

L'impression a duré 1 heure et 17 minutes et a fonctionné du premier coup. Voici le résultat final : 

image.png

La gomme à coté sert d'échelle, elle mesure environ 6 cm et le champignon, autour de 4 cm. 

Ibtyssam

I- Impression 3D

Pour le projet d’impression 3D, j’ai hésité entre plusieurs choses : j’ai d’abord voulu imprimer la Lune, cependant je me suis rendu compte que cela avait déjà été fait donc ça n’aurait pas été très original.

Après plusieurs plusieurs recherches et j’ai eu l’idée d’imprimer un dé. Étant fan de jeu de société je me suis dis que ceserai une super idée, normalement tout petit, mais en grand, soit un dé géant de 15 cm d’arrête. De plus, un dé n’est pas l’objet le plus compliqué à modéliser, certes, cependant cela reste un objet indémodable qui a bercé notre enfance et qui continue aujourd’hui d’ailleurs, car il n’y a pas d’âge pour jouer aux jeux de société.

J’ai utilisé l’application OpenScad car je la trouve beaucoup plus simple et plus intuitive à la prise en main que FreeCad, autre logiciel qui permet la modélisation 3D. Pour m’aider à mener à bien ce projet, je me suis inspiré de certains codes et surtout de la SheetCheat d’OpenScad qui regroupe tous les composés de code dont on a besoin pour modéliser.

Voilà comment je m’y suis prise pour modéliser mon dé :

Étape 1 : la modélisation du cube avec les bords arrondis

 

Ici, il a fallu d’abord modéliser un cube, puis une sphère l’englobant et puis 3 cylindres (rotate) englobant le tout pour enfin faire une intersection entre ses composants et obtenir les bords arrondis.

Ensuite, pour toutes les faces du cube, il a fallu appliquer des sphères et à chaque fois modifier leur position sur chaque face (translate).

Étape 2 : la face du 1

Etape 3 : face du 2 

Étape 4 : la face du 3

Etape 5 : la face du 4 

IMG_9717.jpg

Etape 6 : la face du 5 

IMG_9718.jpg

Etape 7 : la face du 6 (fin)

IMG_9719.jpg

On peut voir que le travail n'est pas très complexe niveau technique car enfait, pour chaque face, on utilise la même fonction (translate), ce sont juste les coordonnées du vecteur afin de placer les demis-sphères sortantes qui changent à chaque fois. 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

translate(v = [x, y, z]) { ... }

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

La commande translate applique une translation (déplace) à son élément enfant (ici la sphère de rayon 1,5 et de résolution 50) le long du vecteur spécifié. 

De plus, pour les dimensions des arrêtes du cube et diamètre des sphères, il faudra voir au stade de l'impression l'échelle à choisir car il n'y a pas d'unité sur OpenScad.

Aussi, j'aurai pu appliquer une différence au tout afin d'avoir un résultat réaliste, comme un vrai dé, mais j'ai décider de  faire des demi-sphères sortantes et non rentrantes pour l'originalité. Aussi, j'ai décidé de faire un dé géant car cela me rappel les grands dés en mousse avec lesquelles je jouait étant petite et desquels je me suis inspirés pour ce projet.

de-mousse-4-cm-couleur-geant-pour-jeu.webp

https://www.google.com/url?sa=i&url=https%3A%2F%2Ftoutpourlejeu.com%2Ffr%2Fde-geant-4-a-8-cm%2F6010-de-mousse-4-cm-couleur-geant-pour-jeu-4260586155433.html&psig=AOvVaw1DCH54Uy-8EMnfUtOVulu9&ust=1711401128672000&source=images&cd=vfe&opi=89978449&ved=0CBIQjRxqFwoTCMDy0pXojYUDFQAAAAAdAAAAABAF

Il reste maintenant à effectuer l'impression !

Le 25 mars 2024, lors d'une séance de Fablab, j'ai lancé la toute première impression de mon objet. 

J'ai tout d'abord choisi une imprimante qui était libre et j'ai choisi ma couleur de filament. Pour faire quelque chose d'un peu original, j'ai choisi du verre. Étant donné que nous ne pouvons pas changer le filament tout seul, j'ai demandé l'aide d'un fabmanager qui a bien voulu le faire pour moi. 

Pendant que celui ci changeait le filament j'ai préparer mon fichier d'impression avec l'aide d'un de mes camarades, Vangu, car je ne savais pas exactement comment procéder. 

En amont, j'ai converti mon fichier OpenScad en format STL, format spécifique l’impression 3D. Je l'ai ensuite mis sur ma clé USB. 

Pour préparer le fichier d'impression, il faut brancher la clé USB sur le poste, ouvrir le logiciel IdeaMaker (slice pour imprimante 3D Raise2pro présente au Fablab) et ouvrir le fichier STL. Ensuite, on choisi les dimensions de notre objet, dans mon cas le sens du dé et le support car la machine ne peut pas imprimer à partit de rien. On visualise le tout et on vérifie que c'est bien ce qu'on veut, on sélectionne l'imprimante et on télécharge le résumé (slice) de l'impression qui nous indique le temps d'impression, le matériau (PMA), l'imprimante et la masse de l'objet. Enfin, on envoie vers l'imprimante et on lance l'impression.

Aussi, il est très important de remplir le registre des impressions en indiquant : date, nom, numéro d'imprimante, matériau (PMA), temps d'impression (pour moi, 2h12), masse (pour moi, 23 g) et résultat.

Pour mon objet, le Fabmanager m'a indiqué que je devais faire attention à la température car selon les filaments elle n'est pas la même. J'ai du choisir une température de 205°.

Aussi, j'ai indiqué précédemment que je voulais imprimer un dé géant de 15 cm d’arête, mais en faisant le fichier d'impression je me suis rendu compte que cela allait être beaucoup trop long (31h). Je ne pouvais pas prendre le risque de faire une impression aussi longue car rien ne me garanti que l'imprimante ne sera pas défaillante. De plus, si c'est le cas, il faudrait que je recommence et c'est beaucoup trop long et de filament gâché. J'ai donc choisi 5 cm d’arête. 

Enfin, j'ai pu lancé mon impression. J'ai fais quelque allers retours pour vérifier que tout allait bien. 

Cependant, à la fin de la séance, un de mes camarades m'a fait remarquer qu'il y a eu un nœud dans mon filament. 

Enfaite, pendant un certains temps, l'imprimante a continué d'imprimer mais sans filament ce qui a causé la création d'un espace vide en plain milieu de mon dé.

J'ai décidé de laisser l'impression se terminer pour voir si le résultat est si mauvais ou non. 

En allant chercher mon dé je me suis rendu compte qu'en plus du défaut décrit précédemment, le haut de mon dé s'est imprimé en décalé. Néanmoins, j'ai décidé de ne pas refaire d'impression car je n'ai pas envie de gâcher plus de filament et car je considère que je sais utiliser les logiciels et faire une impression  3D.

Voici quelques photos du résultat :

image_67905793.JPG

image_67187969.JPG

image_50578433.JPG

image_67131649.JPG

II- Gravure 

Pour mon projet 2D, j’ai décidé de graver un dessin de mon personnage de manga préféré, Jotaro Joestar du manga Jojo’s Bizarre Adventure. 

J’ai décidé de graver cela car j’ai toujours voulu avoir un poster de ce personnage et je trouve ça encore plus stylé d’en avoir une gravure. 

Voici l’image que j’ai décidé de graver :

J’ai donc utilisé le logiciel Inskape pour vectoriser l’image et la mettre en noir et blanc, mais aussi pour modifier certains paramètres afin que la gravure soit à mon goût (résolution, intensité du noir, nuances de gris...). 


 Aussi, il a fallu que je dessine l'encadré du dessin en rouge pour la découpe. 

Après avoir fini tous mes réglages, j'ai enregistré mon projet et l'ai mis sur une clé USB.

Ensuite, je me suis rendu en salle de découpe pour mener à bien ma gravure. J'ai pu la faire grâce à l'aide d'un camarade nommé Vlad qui a eu la gentillesse de m'expliquer comment il fallait procéder. 

Donc il faut mettre sa clé, puis sur le logiciel Trotec Ruby il faut sélectionner son fichier (qui est en .svg), attendre que le logiciel le télécharge et puis faire quelques réglages notamment au niveau des dimensions. Il faut aussi indiquer le bois que nous utilisons (pour moi c'était du peuplier 3mm), pas besoin de sélectionner la découpeuse car c'est un ordi pour une découpeuse. Il faut déposer le morceau de bois dans la découpeuse en dessous du laser dans le coin supérieur gauche et ajuster le laser sur l'ordinateur pour faire en sorte qu'il commence bien sur la coin supérieur gauche de la plaque de bois.

Enfin tous les ajustements fait, la machine nous indique qu'elle est  prête et on peut la mettre en marche. 

Voici quelques images de ma gravure :

Et voila le résultat final !