Petits projets

🌱 Biologie



Arroseur automatique de plantes

Informations

Sean RAMS
ramsean2001@gmail.com
Master informatique : SESI
S02/06/2023 - 20/06/2023

Contexte
Afin de préserver les plantes du fablab durant, je me suis vu attribué la création d'arroseur automatique pour les diverses plantes du fablab.
Objectifs
Réaliser des arroseurs automatique pour diverses plantes.

Matériel

Arduino mega.
Pompes immergé (nombre dépendant du nombre de plante).

Capteurs d'humidité sol  (nombre dépendant du nombre de plante).

Relais (nombre dépendant du nombre de plante).

Bac étanche (ce qui permette de garde les projet font l'affaire).

Planche de bois.
Alimentation 6V, 3A (l'Ampérage n'est pas certains).

Machines utilisées
Aucune

Construction
(Fichiers, photos, code, explications, paramètres d'usinage, photos, captures d'écran...)
Avant tout de chose il faut comprendre que la difficulté du projet n'est pas sur le fait d'arroser une plante mais la mise en échelle sur un groupe d'une quinzaine de plante. Je vous revois vers ce projet ci https://wiki.fablab.sorbonne-universite.fr/BookStack/books/projets-due-2022-2023/page/groupe-a3-apar qui expliquera le principe d'arrosage d'une plante .
Étape 0 (optionnel)
Dans le cas d'une manque de capteur et/ou de pompe, il faut regrouper les plante en différents groupe. Le critère de sélection va être le volume de la terre à arroser mais aussi la consommation des plantes. La consommation peuvent être mesurer en utilisant les capteur d'humidité et en notant dans un tableau l'évolution de l'humidité du sol sur un période.    

Étape 2
Si vous reprenez la planche utiliser pour le fablab, il faut suivre ce schéma : (le numéro des relais serviront dans le code)

Étape 3
Toujours en ce référant aux schéma au-dessus, Il faut établir les différentes connexions. Les maquettes expérimentaux servent uniquement à alimenter les différents composants (Arduino, capteurs, relais et pompes). Tout les composants sont alimentés par la même alimentation (un des générateurs du coin électronique).

Journal de bord
02/06 Premier pas dans le projet:

int sensorPin = A0;
int sensorValue = 0;
int PinR = 7;
int PinV = 8;
int PinB = 4;

void setup() {
 Serial.begin(9600);
 pinMode(PinR,OUTPUT);
 pinMode(PinV,OUTPUT);
 pinMode(PinB,OUTPUT);
 }
void loop() {
 // read the value from the sensor:
 sensorValue = analogRead(sensorPin);
 Serial.print("Moisture = " );
 Serial.println(sensorValue);
 if (sensorValue < 300){
 digitalWrite(PinV,HIGH); 
 digitalWrite(PinR,LOW);
 }
 else {
 digitalWrite(PinR,HIGH); 
 digitalWrite(PinV,LOW);
 }
 delay(1000);
}
15/06 Test d'utilisation de la pompe.

int sensorPin = A0;
int sensorValue = 0;
int PinR = 7;
int PinV = 8;
int PinB = 4;
int pompe = 2;
int serial = 101;

void setup() {
 Serial.begin(9600);
 pinMode(PinR,OUTPUT);
 pinMode(PinV,OUTPUT);
 pinMode(PinB,OUTPUT);
 pinMode(pompe,OUTPUT);
 }
void loop() {
 // read the value from the sensor:
 /* sensorValue = analogRead(sensorPin);
 Serial.print("Moisture = " );
 Serial.println(sensorValue);
 if (sensorValue < 300){
 digitalWrite(PinV,HIGH); 
 digitalWrite(PinR,LOW);
 }
 else {
 digitalWrite(PinR,HIGH); 
 digitalWrite(PinV,LOW);
 }*/

 if (serial >'5' ){
 digitalWrite(pompe,HIGH);
 }else{
 digitalWrite(pompe,LOW);
 }
 if(Serial.available() > 0) {
 serial= Serial.read();
 }
 Serial.println(serial);
 delay(1000);
}
L'idée est de combiner la pompe et le capteur pour alimenter la plante lorsque la terre est sèche.
Code fonctionnel pour arroser une plante en fonction de l'humidité de sa terre.
int sensorPin = A0;
int sensorValue = 0;
int PinR = 7;
int PinV = 8;
int PinB = 4;
int pompe = 2;
void setup() {
 Serial.begin(9600);
 pinMode(PinR,OUTPUT);
 pinMode(PinV,OUTPUT);
 pinMode(PinB,OUTPUT);
 pinMode(pompe,OUTPUT);
 
 digitalWrite(pompe,LOW);
 }
void loop() {
 // read the value from the sensor:
 sensorValue = analogRead(sensorPin);
 Serial.print("Moisture = " );
 Serial.println(sensorValue);
 if (sensorValue > 300){
 
 digitalWrite(PinV,HIGH); 
 digitalWrite(PinR,LOW);
 }
 else {
 
 digitalWrite(PinR,HIGH); 
 digitalWrite(PinV,LOW);
 digitalWrite(pompe,HIGH);
 delay(3000);

 }
 
 digitalWrite(pompe,LOW);
 delay(3000);
}
Début de la programmation en tache distincte pour essayer d'utiliser plusieurs capteur/pompe sur une Arduino.
/*
int sensorPin = A0;
int sensorValue = 0;
int PinR = 7;
int PinV = 8;
int PinB = 4;
int pompe = 2;
*/

#define MAX_WAIT_FOR_TIMER 4

unsigned int waitFor(int timer, unsigned long period){
 static unsigned long waitForTimer[MAX_WAIT_FOR_TIMER]; // il y a autant de timers que de tâches périodiques
 unsigned long newTime = micros() / period; // numéro de la période modulo 2^32 
 int delta = newTime - waitForTimer[timer]; // delta entre la période courante et celle enregistrée
 if ( delta < 0 ) delta = 1 + newTime; // en cas de dépassement du nombre de périodes possibles sur 2^32 
 if ( delta ) waitForTimer[timer] = newTime; // enregistrement du nouveau numéro de période
 return delta;
}

enum {EMPTY, FULL};

struct mailbox_s {
 int state;
 int val;
};

struct mailbox_s mb = {.state = EMPTY};

//tache pour la lecteur d'un des capteurs.

struct CaptHum{
 int timer;
 unsigned long period;
 int pin; 
}

void setup_hum( struct CaptHum * ctx,struct mailbox_s * mb, int timer, unsigned long period, byte pin){
 ctx->timer = timer;
 ctx->period = period;
 ctx->pin = pin;
 pinMode(ctx->pin,INPUT);
}

void loop_lum( struct CaptLum * ctx,struct mailbox_s * mb) {
 if (!waitFor(ctx->timer, ctx->period)) return; // sort s'il y a moins d'une période écoulée
 if (mb->state != EMPTY) return; 
 mb->val = analogRead(ctx->pin);
 mb->state=FULL; 
} 

//Tache d'activation de l'arosage

struct Active{
 int timer;
 unsigned long period;
 int pinpompe;
 int pinledR;
 int pinledV; 
}

void setup_active( struct CaptHum * ctx,struct mailbox_s * mb, int timer, unsigned long period, byte pin){
 ctx->timer = timer;
 ctx->period = period;
 ctx->pin = pin;
 pinMode(ctx->pin,INPUT);
}

void loop_active( struct CaptLum * ctx,struct mailbox_s * mb) {
 if (!waitFor(ctx->timer, ctx->period)) return; // sort s'il y a moins d'une période écoulée
 if (mb->state != EMPTY) return; 
 mb->val = analogRead(ctx->pin);
 mb->state=FULL; 
} 

//tache qui desactive la pompe

struct Desactive{
 int timer;
 unsigned long period;
 int pinpompe;
 int pinledR;
 int pinledV; 
}

void setup_active( struct CaptHum * ctx,struct mailbox_s * mb, int timer, unsigned long period, byte pin){
 ctx->timer = timer;
 ctx->period = period;
 ctx->pin = pin;
 pinMode(ctx->pin,INPUT);
}

void loop_active( struct CaptLum * ctx,struct mailbox_s * mb) {
 if (!waitFor(ctx->timer, ctx->period)) return; // sort s'il y a moins d'une période écoulée
 if (mb->state != EMPTY) return; 
 mb->val = analogRead(ctx->pin);
 mb->state=FULL; 
} 

void setup() {
 /*
 Serial.begin(9600);
 pinMode(PinR,OUTPUT);
 pinMode(PinV,OUTPUT);
 pinMode(PinB,OUTPUT);
 pinMode(pompe,OUTPUT);
 digitalWrite(pompe,LOW); 
 */
 }
void loop() {
 /*
 // read the value from the sensor:
 sensorValue = analogRead(sensorPin);
 Serial.print("Moisture = " );
 Serial.println(sensorValue);
 if (sensorValue > 300){
 
 digitalWrite(PinV,HIGH); 
 digitalWrite(PinR,LOW);
 }
 else {
 
 digitalWrite(PinR,HIGH); 
 digitalWrite(PinV,LOW);
 digitalWrite(pompe,HIGH);
 delay(3000);

 }
 
 digitalWrite(pompe,LOW);
 delay(3000);
 */
}
16/06 : Code pouvant utiliser plusieurs capteur et pompe sur un seul arduino (pour seulement deux dans ce code)
/*
Ne pas modifier cette partie du code
*/

#define MAX_WAIT_FOR_TIMER 16

unsigned int waitFor(int timer, unsigned long period){
 static unsigned long waitForTimer[MAX_WAIT_FOR_TIMER]; // il y a autant de timers que de tâches périodiques
 unsigned long newTime = millis() / period; // numéro de la période modulo 2^32 
 int delta = newTime - waitForTimer[timer]; // delta entre la période courante et celle enregistrée
 if ( delta < 0 ) delta = 1 + newTime; // en cas de dépassement du nombre de périodes possibles sur 2^32 
 if ( delta ) waitForTimer[timer] = newTime; // enregistrement du nouveau numéro de période
 return delta;
}

enum {EMPTY, FULL};
//Structure mail box servant au tache à communiquer.
struct mailbox_capteur {
 int state;
 int val;
};

struct mailbox_timer {
 int state;
 unsigned long time_stop;
};

//tache pour la lecteur d'un des capteurs.

struct CaptHum{
 int timer;
 unsigned long period;
 int pin; 
};

void setup_hum( struct CaptHum * ctx,struct mailbox_capteur * mb_cap, int timer, unsigned long period, int pin){
 /*
 	Fonction permetant d'initialiser une tache qui va périodiquement effectuer des messures d'humidité. 
 
 ctx : Pointeur vers la suctruture qui va être initialiser 
 mb_cap: pointeur vers la mailbox permetant d'enregistrer la messure du capteur et la transmetre à la tache d'activation de la pompe
 timer : Identifier UNIQUE permetant à wait timer d'excuter la messure périodiquement.
 period : Indique le temps d'attente minimal entre deux messure (malereusement en unité inconnue mais suposser être des millisecondes)
 pin : Pin ANALOGIQUE utiliser pour prendre la messure.
 */
 //Initialisation des timer et period pour le waitfor permetant d'organiser les taches.
 ctx->timer = timer;
 ctx->period = period;
 
 ctx->pin = pin;
}

void loop_hum( struct CaptHum * ctx,struct mailbox_capteur * mb_cap, struct mailbox_timer *mb_time ) {
 /*
 	Fonction permetant effectuer des messures d'humidité périodiquement sur un capteur donné. 
 
 ctx : Pointeur vers la suctruture qui a été initialiser 
 mb_cap : pointeur vers la mailbox permetant d'enregistrer la messure du capteur et la transmetre à la tache d'activation de la pompe
 	mb_time : pointeur vers la mailbox permetant d'ârréter la pompe, présente pour eviter de prendre des messure lorsque la pompe est active.
 */
 if (mb_cap->state != EMPTY) return;
 if (mb_time->state != EMPTY) return;
 if (!waitFor(ctx->timer, ctx->period)) return; // sort s'il y a moins d'une période écoulée
 
 
 mb_cap->val = analogRead(ctx->pin);

 Serial.print(String("Moisture ")+String(ctx->timer)+String(" = ") );
 Serial.println(mb_cap->val);

 mb_cap->state=FULL; 
} 

//Tache d'activation de l'arosage

struct Active{
 int pinpompe;
 int pinledR;
 int pinledV;
 int seuil;
 int time_active; 
};

void setup_active( struct Active * ctx, int pinpompe, int pinledR, int pinledV, int seuil, unsigned long time_active){
 /*
 	Fonction permetant d'initialiser une tache qui va si la meussure reçu est trop faible activer la pompe. 
 
 ctx : Pointeur vers la suctruture qui va être initialiser 
 pinpompe : Pin controlant la pompe.
 pinledR : Pin controlant la led rouge.
 pinledV : Pin controlant la led vert.
 seuil : Seuil pour lequel la terre est considére comme trop séche.
 time_active : temps d'activation de la pompe en milliseconde (environ) 
 */
 //Initialisation des pin de la pompe, des led rouge et vert pour une tache active 
 ctx->pinpompe = pinpompe;
 ctx->pinledR = pinledR;
 ctx->pinledR = pinledR;
 
 //Setup des différente pin utiliser.
 pinMode(ctx->pinpompe,OUTPUT);
 pinMode(ctx->pinledR,OUTPUT);
 pinMode(ctx->pinledV,OUTPUT);
 
 //Initialisation des variable pour activer la pompe et sa durée
 ctx->seuil = seuil;
 ctx->time_active = time_active;

 //Désactive la pompe dans son setup
 digitalWrite(ctx->pinledR,LOW); 
 digitalWrite(ctx->pinledV,HIGH); 
 digitalWrite(ctx->pinpompe,LOW);
}

void loop_active( struct Active * ctx, struct mailbox_capteur * mb_cap, struct mailbox_timer * mb_time) {
 /*
 	Fonction permetant d'activer la pompe pour un temps donné. 
 
 ctx : Pointeur vers la suctruture de la tache qui a été initialiser 
 mb_cap : pointeur vers la mailbox permetant d'enregistrer la messure du capteur et la transmetre à la tache d'activation de la pompe
 	mb_time : pointeur vers la mailbox permetant d'ârréter la pompe, présente pour eviter de prendre des messure lorsque la pompe est active.
 */
 //Test des différentes condiction avant d'activer la pompe 
 if (mb_cap->state != FULL) return;
 if (mb_cap->val <= ctx->seuil ) {
 //Alumage de la led rouge et de la pompe (+ étient la led vert) pour signaler que la plante est arroser 
 digitalWrite(ctx->pinledR,HIGH); 
 digitalWrite(ctx->pinledV,LOW);
 digitalWrite(ctx->pinpompe,HIGH); 
 
 //Initialise la mailbox pour étiendre la pompe 
 mb_time->time_stop = millis() + ctx->time_active;
 mb_time->state=FULL;
 Serial.println(String("Pompe active ")+ctx->pinpompe);
 }
 mb_cap->state = EMPTY; 
} 

//tache qui desactive la pompe

struct Desactive{
 int pinpompe;
 int pinledR;
 int pinledV; 
};

void setup_desactive( struct Desactive * ctx, int pinpompe, int pinledR, int pinledV){
 /*
 	Fonction permetant d'initialiser une tache qui va si la meussure reçu est trop faible activer la pompe. 
 
 ctx : Pointeur vers la suctruture qui va être initialiser 
 pinpompe : Pin controlant la pompe. (doit être la même que celle de la tache d'activation de la pompe associé)
 pinledR : Pin controlant la led rouge.(doit être la même que celle de la tache d'activation de la pompe associé)
 pinledV : Pin controlant la led vert.(doit être la même que celle de la tache d'activation de la pompe associé)
 */
 ctx->pinpompe = pinpompe;
 ctx->pinledR = pinledR;
 ctx->pinledV = pinledV;
 
 pinMode(ctx->pinpompe,OUTPUT);
 pinMode(ctx->pinledR,OUTPUT);
 pinMode(ctx->pinledV,OUTPUT);

 
 digitalWrite(ctx->pinledR,LOW); 
 digitalWrite(ctx->pinledV,HIGH); 
 digitalWrite(ctx->pinpompe,LOW);
}

void loop_desactive( struct Desactive * ctx, struct mailbox_timer * mb_time) {
 /*
 	Fonction permetant de desactiver la pompe apres un temps donné par la mailbox timer. 
 
 ctx : Pointeur vers la suctruture de la tache qui a été initialiser
 	mb_time : pointeur vers la mailbox permetant d'ârréter la pompe, présente pour eviter de prendre des messure lorsque la pompe est active.
 */
 Serial.println(String("mb time desa = ")+mb_time->state+" "+mb_time->time_stop);
 Serial.println(String("millis = ")+millis());
 if (mb_time->state != FULL) return; 
 if( millis()>= mb_time->time_stop){
 digitalWrite(ctx->pinledR,LOW); 
 digitalWrite(ctx->pinledV,HIGH); 
 digitalWrite(ctx->pinpompe,LOW);
 Serial.println("Pompe desactive "+ctx->pinpompe);
 mb_time->state = EMPTY; 
 } 
} 

// Declaration des tache et des mailbox (si ajout de capteur et/ou pompe à faire à partir d'ici)

//mail box
struct mailbox_capteur mb_cap0 = {.state = EMPTY};
struct mailbox_timer mb_time0 = {.state = EMPTY};

struct mailbox_capteur mb_cap1 = {.state = EMPTY};
struct mailbox_timer mb_time1 = {.state = EMPTY};

//tache
struct CaptHum Hum0;
struct Active acti0;
struct Desactive desa0;

struct CaptHum Hum1;
struct Active acti1;
struct Desactive desa1;

void setup() {
 Serial.begin(9600);

 setup_hum(&Hum0, &mb_cap0, 0, 1000, A0); 
 setup_active(&acti0, 2, 7, 8, 400, 2000);
 setup_desactive(&desa0, 2, 7, 8);
 
 setup_hum(&Hum1, &mb_cap0, 1, 1000, A1); 
 setup_active(&acti1, 12, 13, 22, 400, 2000);
 setup_desactive(&desa1, 12, 13, 22);
}
void loop() {
 loop_hum(&Hum0, &mb_cap0, &mb_time0); 
 loop_active(&acti0, &mb_cap0, &mb_time0);
 loop_desactive(&desa0, &mb_time0);

 
 loop_hum(&Hum1, &mb_cap1, &mb_time1); 
 loop_active(&acti1, &mb_cap1, &mb_time1);
 loop_desactive(&desa1, &mb_time1);
}
19/06:
Pour ajouter des nouveaux capteurs, il faut créé deux nouvelles mail box de chaque type ( mailbox_capteur et mailbox_timer), une nouvelle tâche de chaque type (CaptHum, Active et Desactive).Il faut ensuite les setups de la même manière que sur le code déjà présent chaque variable est expliqué dans les commentaire de chaque fonction. Il est important de d'avoir en commun sur active et desactive les pin pour la pompe et led. Les leds servent pour le débug est ne sont pas nécessaire à brancher.  Puis il faut ajouter les fonction loop avec les tache et les mail créer.

Schéma des connexions pour faire fonctionner le code au dessus (sans certaine led).

Il faut noté que le capteur à 4 pin cependant la pin non labéliser (entre VCC et SIG) ne sert a rien et donc nécessite aucune connexion.

23/06:
Simplification électronique, la commande des moteurs a été grandement simplifié. Au lieu d'utilisé des relais pour commander les moteurs, nous utilisons maintenant des transistors (comme switch électronique). Les moteurs son alimenté indépendamment de l'Arduino nano.
Nouveau schéma électronique :

Et dessin de la PCB :

Nous utilisons 7 capteurs d'humidités et 7 pompes (le nombre max dispo au fablab).
Le système de signalement lors du fonctionnement a été modifié. Au lieu de 2 LED (Verte et Rouge) pour indiquer que rien ne se passe ou il y a besoin d'arrosage, cela est remplacé par une LED sur chaque moteur, si elle est allumé alors il y a arrosage.
Modification du code pour correspondre au besoin.
03/07
Par manque de compréhension du PCB, nous continuons le projet avec la première solution.Expérience de sciences participatives - Avons nous peur de conserver les grillons ?

Minya Erre, Mattéo Regnard, Nina Sacco, Hugo Tichit, Amy Weisenfeld

Encadrant : Julien Gasparini MUBEB02 - Février 2024
I. Introduction

Malgré l’importance des insectes dans le monde et dans le fonctionnement des écosystèmes, le déclin global de ce groupe ne se questionne plus. Que ce soit par le changement climatique, la perte et la fragmentation d’habitat ou encore l’agriculture, la diversité et l’abondance de ces organismes diminuent.  Pourtant,  ils ne constituent que 8% des espèces évaluées par la liste rouge de l’IUCN et les programmes de conservation comme les aires protégées manquent d’efficacité pour leur bonne protection (Chowdury et al., 2023, Hallmann et al., 2017).
Les insectes jouent pourtant des rôles clés et fournissent des services importants aux populations humaines (Cardoso et al, 2011). Cet aspect utilitariste est généralement pris en compte dans le cadre de projets de conservation, mais il arrive que d’autres éléments de nature psychologique puissent influencer le désir de conservation et la propension à payer pour celle-ci.

En effet, l’empathie ou la compassion peuvent biaiser les efforts mis en place en faveur d’espèces esthétiquement plaisantes ou simplement plus proches des des humains phylogénétiquement, outre les services qu’elles peuvent rendre (Miralles et al., 2019). À l’inverse, des états émotionnels négatifs comme la peur ou le dégoût peuvent desservir la cause de certains organismes, comme cela pourrait être le cas avec les grands carnivores (Notaro et Grilli, 2022).
Les insectes sont particulièrement enclins à déclencher ces états émotionnels négatifs. L'entomophobie, la peur des insectes, est largement répandue, et est généralement  liée à un dégoût pour ces organismes (Fukano et Soga, 2023). Ce facteur psychologique, s’ajoutant au manque de connaissances pourrait ainsi influencer négativement les efforts de conservation mis en place pour ces organismes.

Aussi, nous avons cherché à savoir si le désir de conservation d’une espèce pouvait être corrélé à l’aversion pour celle-ci, en choisissant un exemple issu du clade des insectes : le grillon domestique Acheta Domesticus.
II. Matériel et méthode

Première partie sur la conservation

Matériel :

15 images plastifiées d’espèces de taxons variés : mésange charbonnière (Parus major), castor d’Eurasie (Castor fiber), couleuvre à collier (Natrix helvetica), escargot petit-gris (Cornu aspersum), crabe marbré (Pachygrapsus marmoratus), méduse pélagique (Pelagia noctiluca), crapaud calamite (Epidalea calamita), lombric commun (Lumbricus terrestris), araignée (Evarcha arcuata), abeille domestique (Apis mellifera), renard roux (Vulpes vulpes), chouette effraie (Tyto alba), étoile de mer rouge (Echinaster sepositus), perche (Perca fluviatilis), grillon domestique (Acheta domesticus)

Étiquettes (de 1 à 15) scotchées sur la table

Un chronomètre

Protocole :
L’expérimentateur-rice demande à l’individu dans un premier temps de classer 15 images d’espèces de taxons variés sur une échelle de 1 à 15. 1 étant l’espèce qu’il ou elle souhaite le plus protéger et 15 l’espèce qu’il ou elle souhaite le moins protéger. Le sujet possède deux minutes pour réaliser l’exercice.

Deuxième partie sur l’aversion

La deuxième expérience (du vendredi 2 février 2024) est une version améliorée de la première (du mercredi 31 janvier 2024).

Expérience du mercredi 31 janvier 2024 (Exp 1)

Expérience du vendredi 2 février 2024 (Exp 2)

Matériel

- Boîtes en plastique (tupperwares/contenants)
- Tissus pour cacher l’intérieur des boîtes
- Scotch
- Glace
- 3 boîtes de grillons vivants, taille 6
- Œufs de caille (1 par salle)
- Boîtes de gants

- Béchers en verre (1 par salle) pour récupérer l’œuf lors de la manipulation “contrôle”
- Contenants en plastique (2 par salle, 1 par manipulation) pour déposer l’œuf après récupération
- Sacs en plastique noir (2 par salle)
- 4 boîtes de grillons vivants, taille 6 (2 boîtes par manipulation)
- Œufs de caille (2 par salle)
- Boîtes de gants

Protocole

L’expérimentateur-rice demande à l’individu de déplacer un œuf de caille d’une boîte en plastique posée dans une boîte en plastique plus grande et couverte par du tissu pour cacher l’intérieur à un autre contenant. La boîte est couverte par un tissu avant le début de cette manipulation “contrôle”.

Ensuite, l’expérimentateur-rice demande au sujet de réaliser le même transfert, mais cette fois-ci avec un grillon vivant à la place de l’œuf. Dans la grande boîte en dessous de la plus petite, il y a de la glace pour endormir le grillon pour éviter qu’il ne s’échappe. La boîte est couverte par un tissu jusqu’au début de la manipulation.

L’expérimentateur-rice demande à l’individu de déplacer un œuf de caille d’un grand bécher à un autre contenant. Le bécher est couvert par un sac plastique noir avant le début de cette manipulation “contrôle”.

Ensuite, l’expérimentateur-rice demande au sujet de réaliser le même transfert, mais cette fois-ci l’œuf est caché sous un carton dans une boîte contenant une trentaine de grillons vivants et non endormis. Cette boîte est positionnée dans une boîte en plastique plus grande pour éviter que les grillons s’échappent. La grande boîte est couverte par un sac plastique noir jusqu’au début de la manipulation.

Tableau 1 : Le matériel et le protocole pour chaque expérience

III.    Résultats

Expérience transfert d’un grillon seul (Exp 1)

a) Résultats moyens
On observe une grande  majorité de scores de peur/dégoût ou aversion entre 1 et 2 (Fig. 3b/c/d). Les scores de conservation sont répartis de manière un peu plus homogène, mais la plupart se situent entre 10 et 15 avec un maximum d'observations entre 12 et 14 (Fig. 3a).
Les effectifs entre les genres  “Homme” et “Femme” sont assez proches et supérieurs à 30 (Fig.4). Une personne “Non-Binaire” a également participé à l’expérience. On retrouve en revanche beaucoup plus de personnes ayant grandi en milieu urbain que rural (Fig.5). Pour ce qui est des domaines d’étude, on retrouve une majorité d’étudiants en écologie et en biologie, chimie ou médecine (Fig. 6).
b) Vérification de la validité de notre mesure d’aversion

Dans les deux cas, la p-value est très inférieure au risque alpha de 5%, il y a donc une corrélation positive entre l’aversion mesurée et le dégoût/la peur déclarée (Fig.7).
On peut donc noter que notre mesure d’aversion s’est avérée plutôt cohérente au regard des scores d’aversion auto-administrés par les participant-e-s. Dans la suite de l’analyse de l'expérience 1, nous choisissons donc de n'étudier que le score d’aversion mesuré.

c) Conservation-aversion, conservation-peur, conservation-dégoût : Quels liens ?

Pour rappel le score de conservation est compris entre 1 et 15, un score de 1 indique que la volonté de conservation pour le grillon est élevée tandis qu’un score de 15 indique que la volonté de conservation est très faible.  Les résultats de la conservation en fonction de l’aversion ne présentent pas de corrélation significative. On note une tendance à obtenir un score de conservation plus élevé (proche de 1)  quand l’aversion est plus forte (Fig. 8). Les résultats de la conservation en fonction de la peur et du dégoût déclarés ne présentaient pas non plus de corrélations significatives.
d) Existe-t-il des biais pouvant affecter les réponses ?

Ces boxplots présentent la conservation (fig. 9) ou l’aversion (fig. 10) en fonction de nos facteurs analysés. Pour la conservation, on observe un léger effet “origine” et “genre expérimentateur-rice” avec un rang de conservation moyen plus élevé (on rappelle 1 étant celui qu’on veut le plus conserver) en présence d’un expérimentateur (par rapport à une expérimentatrice) et pour un individu ayant grandi en milieu urbain (par rapport au milieu rural). On observe également un effet du domaine d’étude, mais celui-ci peut être dû aux effectifs inégaux dans chaque groupe. Par exemple, seuls 2 individus sont présents dans le groupe “g” (géosciences). De même pour les boxplots de l’aversion. Malheureusement, les tests statistiques ne nous ont pas permis de conclure sur un effet significatif des facteurs sur nos résultats.

Lorsque interrogé-e-s sur leurs ressenti pendant les expériences, nombreux-ses participant-e-s ont mentionné une peur minimisée par la présence d’un seul grillon, et précisant que l’impression aurait été plus forte face à des insectes “grouillants”, nombreux, pouvant leur sauter dessus etc. C’est pour cette raison que nous avons décidé de mener une expérience “améliorée” le vendredi 2 février, dont les résultats sont décrits ci-dessous.

Expérience effet grouillant des insectes (Exp 2)

a) Résultats moyens

De manière similaire à la première expérience, on observe une majorité de scores d’aversion, de dégoût ou de peur entre 1 et 2. Nous avons néanmoins obtenu plus d’observations pour les autres scores (Fig. 11b/c/d). On observe une majorité de scores de conservation entre 12 et 14, et les scores sont plus homogènes que ceux pour l’aversion, le dégoût ou la peur (Fig. 11a).
Les effectifs entre les genres “Homme” et “Femme” sont quasiment équivalents. Une personne “Non-binaire” a participé à l’expérience (Fig. 12a). De manière similaire à l’expérience 1, plus de personnes originaires d’un milieu urbain ont participé à l’expérience (Fig. 12b). Une majorité d’étudiants en écologie  a été interrogée.
b) Vérification de la validité de notre mesure d’aversion

Dans les deux cas, la p-value est très inférieure au risque alpha de 5%, il y a donc une corrélation positive entre l’aversion mesurée et le dégoût/la peur déclarée (Fig.13, Fig. 14).
On peut donc noter que notre mesure d’aversion s’est avérée plutôt cohérente au regard des scores d’aversion auto-administrés par les participant-e-s. Dans la suite de l’analyse de l'expérience 2, nous choisissons donc de n'étudier que le score d’aversion mesuré.
c) Conservation - aversion : Quels liens ?

Pour rappel le score de conservation est compris entre 1 et 15, un score de 1 indique que la volonté de conservation pour le grillon est élevée tandis qu’un score de 15 indique que la volonté de conservation est très faible.  Les résultats de la conservation en fonction de l’aversion ne présentent pas de corrélation significative (p-value>0.05). On note une tendance à obtenir un score de conservation plus faible (proche de 15) quand l’aversion est plus forte (Fig. 15).Les résultats de la conservation en fonction de la peur et du dégoût déclarés ne présentaient pas non plus de corrélations significatives.
d) Existe-t-il des biais pouvant affecter les réponses ?

Comme pour la première expérience, on peut observer une certaine tendance pour le facteur “domaine”, notamment pour la conservation mais sans effet significatif. De même pour les autres facteurs.
c)Comparaison des résultats expérience 1 et 2

Jour d'expérience

Nombre de participants

Score de conservation moyen

Score aversion moyen

Score peur moyen

Score de dégoût moyen

Mercredi - Expérience 1

66

10.95

2.67

2.47

2.3

Vendredi - Experience 2

84

11.07

3.79

3.45

3.75

Tableau 2 : Résultats moyens obtenus sur les différentes expériences.

L’expérience 2 a comporté plus de participants. En moyenne,tous les scores sont plus élevés lors de l’expérience 2 (Tab. 2).

On observe une différence significative (p-value<0.05) entre les scores d’aversion des deux expériences, avec des scores plus élevés lors de l’expérience 2 (Fig. 18). Aucune différence significative n’est détectée (p-value>0.05) pour les scores de conservation (Fig. 19).

On observe une différence significative (p-value<0.05) entre les scores de peur (Fig. 20) et de dégoût (Fig. 21)  des deux expériences, avec des scores plus élevés lors de l’expérience 2.
IV.     Discussion et conclusion

Biais et limites

Un des points les plus intéressants de cet exercice méthodologique était de se rendre compte du nombre extrêmement important de biais, potentiels ou effectifs.

Nous pouvons séparer ceux-ci en deux catégories : les biais expérimentaux potentiels, auxquels nous avions pensés avant l’expérience, et que nous nous sommes appliqués à contrôler ; et les biais expérimentaux sur lesquels nous nous posons toujours des questions, soit parce que nous ne les avions pas anticipés, soit parce que nous doutons de leur importance/impact sur les résultats.
Les biais anticipés transparaissent dans notre protocole. Mais au vu des résultats non significatifs, alors que la bibliographie sur le sujet nous avait poussé à émettre l’hypothèse d’un effet de l’aversion pour le grillon sur le score de conservation attribué, nous allons nous attarder sur les différents biais expérimentaux qui ont pu influencer nos résultats.

a.  Le corpus interrogé

La très grande majorité des sujets (98.8%) de notre expérience sont des étudiant-e-s, en licence, master ou thèse. La totalité des interrogé-e-s pour la deuxième expérience travaillent par ailleurs dans le domaine des sciences (maths, physique, chimie, biologie). Nous nous attendions à un tel corpus sans pouvoir limiter ce biais, pour des raisons de logistique évidentes (manque de temps, manque de moyens, manque de volontaires ou de contacts dans d’autres domaines).

Dans la même idée, nous avions pensé que l’origine rurale ou urbaine des participant-e-s pourrait avoir une influence (Fukano et Soga, 2023), nous avons donc questionné les participant-e-s sur leur origine (environ 31% d’entre eux-elles se sont déclaré-e-s comme étant d’origine rurale) et au vu des boxplots, il pourrait effectivement y avoir un effet de l’origine sur le score d’aversion du grillon. Nous suspections également un effet du genre sur nos résultats. Non seulement nous avons eu la chance d’avoir quasiment le même nombre de sujets de genre masculin et féminin (42 et 41) mais en plus il n’y a pas d’effet significatif du genre sur le score de conservation (p valeur > 0.05) ni sur le score d’aversion (p valeur > 0.4) .De nombreuses autres questions auraient été possibles et intéressantes, elles ressortent dans plusieurs articles où du public est impliqué (quel est le rapport du participant à la chasse, à l’écologie par exemple). D’autres biais ont ainsi pu se glisser dans nos données. Par manque de temps et pour faciliter le passage de nombreux participants, nous avons choisi de réaliser un questionnaire très succinct, cependant, cela a pu avoir une influence sur nos résultats.

b.  L’expérimentateur-rice

L’expérimentateur-rice, ou son genre, a pu influencer le score de conservation ou d’aversion pour le grillon, il n’en est rien. Les tests de comparaison de moyenne donnent des résultats non significatifs.

c.  Le déroulé de l’expérience :

Plusieurs erreurs méthodologiques nous semblent importantes à relever.

Le contrôle : nous avions décidé d’utiliser un œuf de caille à déplacer par le sujet, d’une boîte vide à l’autre, pour vérifier que le sujet était capable de déplacer cet objet, qu’il n’était pas dégoûté ou qu’il refuserait de le faire. Nous pouvions ainsi retirer l’effet “oeuf” pour n’observer que l’effet “grillon”. Cependant au cours du contrôle l'œuf n’était pas positionné sous un carton, alors qu’il l’était dans l’enclos des grillons. Il y avait donc potentiellement un effet “œuf caché”. Nous avions décidé de positionner l'œuf sous un carton également dans le contrôle mais les expérimentateur-rices l’ont oublié dans les premiers réplicats, et ne voulant pas perdre de données, nous avons décidé de continuer comme cela. On peut ajouter que nous n’avons pas réellement mesuré l’effet “oeuf” : en effet tous-tes les participant-e-s ont réalisé notre contrôle. Nous avons simplement vérifié qu’ils-elles le faisaient, sans différencier les participant-e-s hésitant-e-s ou lent-e-s. Nous avons donc considéré que l’effet “oeuf” était le même pour tous-tes ce qui n’est pas forcément faux, mais nous ne l’avons pas réellement prouvé.

L’effet blouse : nous savons que la blouse peut avoir un effet convaincant, ou de confiance du sujet envers l’expérimentateur-rice, le rendant plus enclin à effectuer les tâches demandées. Ce biais était contrôlé car tous les expérimentateur-rices ont porté une blouse au cours des expériences. Cependant, cela a pu diminuer la variance de nos résultats, et faire diminuer le score d’aversion mesuré. Plusieurs sujets se sont excusés, et ce à plusieurs reprises, de ne pas vouloir aller chercher l'œuf. Cela peut suggérer que d’autres, hésitants, ont surpassé leur peur pour “faire plaisir” à l’expérimentateur-rice.

L’effet glace : cet effet concerne la première version de notre expérience : certains grillons étaient plus affectés que d’autres par la température artificiellement abaissée. Certains étaient ralentis, d’autres semblaient complètement morts. On peut supposer que cela avait un effet non négligeable sur la manipulation par le sujet. Nous avons décidé d’éliminer ce biais dans la deuxième expérience en demandant au sujet de déplacer un œuf et de ne plus anesthésier les grillons.

L’effet “organisme inconnu” : certains sujets ont manifesté qu’ils ne connaissaient pas les insectes dans la boîte, ou demandaient si ils étaient dangereux. Cela a pu influencer nos résultats, et nous n’avons malheureusement pas pris en compte cette éventualité, pensant que tous reconnaitraient l’animal.

Effet de l’ordre des tâches : nous avons délibérément choisi de faire faire le classement avant la manipulation sur le score d’aversion. Il nous semblait important de ne pas influencer le classement du grillon par la manipulation mais nous ne pouvons pas exclure un effet de déconcentration ou de fatigue, néanmoins mesuré, au vu de la courte durée de l’expérience (dans l’immense majorité inférieur à 5 minutes).

Effet intrus : le passage dans la salle a pu influencer les résultats de certains sujets. Des sujets ont par exemple exprimé que “devant mes amis je l’aurai fait”. On ne peut donc pas exclure que des passages d’autres utilisateurs du greenlab aient dérangé ou poussé les sujets à réaliser les tâches demandées.

2.Interprétation
Nous proposons ensuite quelques interprétations à nos résultats.La différence observée entre les deux expériences s’explique probablement par le nombre d’organismes dans la boîte. En effet, une mesure de la peur pour des organismes peut être différente si l’organisme est présenté seul ou en groupe. Par exemple, la présentation d’une image à caractère effrayant d’un loup seul a un moindre impact sur l’état émotionnel qu’une meute de loup de plus de 50 individus (Notaro et Grilli, 2022). Cela a pû être le cas dans notre seconde expérience où nous avons mesuré une aversion plus forte que lors de la première expérience.
La perception des insectes est largement subjective et les facteurs sous-jacents sont peu étudiés. On retrouve des disparités que nous avons retrouvées parmi les participant-e-s de l’expérience, avec des personnes phobiques et d’autres fascinées par ces organismes (Simaika et Samways, 2018).  Une étude dans une université américaine a montré que les insectes étaient perçus par les étudiant-e-s d'une manière similaire aux pathogènes, ce qui expliquerait le dégoût pour ceux-ci. Les caractéristiques précises qui mènent à cette perception restent incertaines. Dans notre expérience, un biais lié à un parcours universitaire en sciences techniques était attendu, dûe à une habitude et une connaissance plus poussée en biologie, mais cela n’a pas été détecté dans l’étude de Lorenz et al, 2014. Nous n’avons pas non plus détecté cet effet dans nos résultats. 
Au-delà de comprendre d’où provient l’aversion pour les insectes, les conséquences que celle-ci peut avoir en termes de conservation sont peu étudiées. Les connaissances autour de l’effet de l’entomophobie à l’échelle individuelle sur des situations à plus grande échelle comme la conservation reste pour le moment mal connues, et les solutions pour mitiger cette phobie restent limitées (Simaika et Samways, 2018).

D’après nos résultats, et malgré tous les biais mentionnés plus haut, l’aversion pour le grillon ne semble pas influencer l’envie de le conserver. Simaika et Samways (2018) mettent en avant la multiplicité des facteurs psychologiques pouvant influencer la perception des insectes. De plus, Cardoso et al. (2011) relèvent que le principal frein à la conservation des invertébrés reste leur méconnaissance par le public et les acteurs pour leur conservation.
Nous avons effectivement remarqué que de nombreux sujets semblaient ne pas prêter attention au grillon lors de l’exercice sur la conservation. Il pourrait être très intéressant de mesurer l’indifférence que le sujet ressent envers le grillon. Il semble que pour nombre des participant-e-s, la position ait été déterminée un peu “par défaut”. Cela influence-t-il l’envie de conservation, et quels sont les facteurs qui pourraient expliquer cette indifférence? Cette question nous apparaît comme la suite logique de nos expérimentations.

IV. Bibliographie

CARDOSO, Pedro, ERWIN, Terry L., BORGES, Paulo A. V. et NEW, Tim R. The seven impediments in invertebrate conservation and how to overcome them. Biological Conservation. [en ligne]. 1 novembre 2011. Vol. 144, n° 11, pp. 2647‑2655. [Consulté le 7 février 2024]. DOI 10.1016/j.biocon.2011.07.024.

CHOWDHURY, Shawan, ZALUCKI, Myron P., HANSON, Jeffrey O., TIATRAGUL, Sarin, GREEN, David, WATSON, James E. M. et FULLER, Richard A. Three-quarters of insect species are insufficiently represented by protected areas. One Earth. [en ligne]. 17 février 2023. Vol. 6, n° 2, pp. 139‑146. [Consulté le 7 février 2024]. DOI 10.1016/j.oneear.2022.12.003.

FUKANO, Yuya et SOGA, Masashi. Evolutionary psychology of entomophobia and its implications for insect conservation. Current Opinion in Insect Science. [en ligne]. 1 octobre 2023. Vol. 59, pp. 101100. [Consulté le 7 février 2024]. DOI 10.1016/j.cois.2023.101100.

HALLMANN, Caspar, SORG, Martin, JONGEJANS, Eelke, SIEPEL, Henk, HOFLAND, Nick, SCHWAN, Heinz, STENMANS, Werner, LLER, Andreas, SUMSER, Hubert, HÖRREN, Thomas, GOULSON, Dave et KROON, Hans. More than 75 percent decline over 27 years in total flying insect biomass in protected areas. PLoS ONE. 18 octobre 2017. Vol. 12, pp. 1‑21. DOI 10.1371/journal.pone.0185809.

LORENZ, Amanda R., LIBARKIN, Julie C. et ORDING, Gabriel J. Disgust in response to some arthropods aligns with disgust provoked by pathogens. Global Ecology and Conservation. [en ligne]. 1 décembre 2014. Vol. 2, pp. 248‑254. [Consulté le 12 février 2024]. DOI 10.1016/j.gecco.2014.09.012.

MIRALLES, Aurélien, RAYMOND, Michel et LECOINTRE, Guillaume. Empathy and compassion toward other species decrease with evolutionary divergence time. Scientific Reports. [en ligne]. 20 décembre 2019. Vol. 9, n° 1, pp. 19555. [Consulté le 7 février 2024]. DOI 10.1038/s41598-019-56006-9.

NOTARO, Sandra et GRILLI, Gianluca. How much Fear? Exploring the Role of Integral Emotions on Stated Preferences for Wildlife Conservation. Environmental Management. [en ligne]. 1 mars 2022. Vol. 69, n° 3, pp. 449‑465. [Consulté le 7 février 2024]. DOI 10.1007/s00267-022-01593-z.

SIMAIKA, John P. et SAMWAYS, Michael J. Insect conservation psychology. Journal of Insect Conservation. [en ligne]. 1 août 2018. Vol. 22, n° 3, pp. 635‑642. [Consulté le 7 février 2024]. DOI 10.1007/s10841-018-0047-y.
Annexe

Annexe 1 : Schéma expérimental pour le classement des organismes.

Modèle de documentation générique

🧪 Chimie



Super Condensateur au Graphène LIG Avec du kapton + Decoupeuse laser


Vidéo Youtube Sur la chaine de la Société chimique de France
tout est expliqué dedans amusez vous bien!
Informations

René Meng
rene.meng@etu.S-U.fr
M1 Chimie Stage au Laboratoire LISE
Juin-Juillet 2022

Contexte
Vidéo Breaking taps 
qui se base sur cette publi https://rdcu.be/cMAKU
J'ai donc réalisé une video proof of concept grace au fablab avec du scotch de kapton

Objectifs
Reproduire l'experience et allumer une LED.
Matériel

Feuille de polyimide ou Kapton

Machines utilisées
Trotec Speedy 100
Construction
Voir la vidéo
Journal de bord
Disponible sur mon site web https://renemeng.wordpress.com/2022/12/24/supercondensateur-au-graphene-lig-obtention-du-prix-l3-societe-chimique-de-france/Impression 3D électrochimique : Réalisation d'un réseau d'électrodes

Ce que j'ai fait au fablab:

Réseau d'électrode 6*6 sur PMMA recouvert d'or pour une application à l'impression 3D par voie électrochimique.
Introduction au sujet:

https://drive.google.com/file/d/1nkw5Zwh1voD9N_fGageRGOvbt9gQq36m/view?usp=sharing

Dans le cadre d'un projet entrepreneurial, j'ai proposé un sujet de stage au Laboratoire Interface et Systèmes Electrochimique (LISE) un sujet de stage qui a été validé, sur l'impression 3D électrochimique.

Le fonctionnement est similaire à une impression resine, car celle-ci permet d'imprimer couche par couche mais en revanche au lieu d'imprimer en résine, elle imprime des metaux tel que le cuivre.

La tête d'impression consiste d'un reseau d'electrode et chacune permet d'effectuer la reaction d'électrodépot, c'est a dire de convertir les atomes de cuivre en solution (bleu), vers sa forme solide(orange).

Pour ce faire il a été envisagé de fabriquer cette tête d'impression au fablab sur une plaque de plexiglas recouverte d'or, puis en realisant le motif des electrodes avec une graveuse laser.

À l'issue de ce stage, je voudrais lancer une startup sur ce projet, et proposer un service d'impression métal pour un marché en plein essor.
. En revanche les techniques se sont orienté depuis 1996 sur des méthode par écriture directe, par la polarisation de la cathode. Cela permet notamment d'imprimer des pièces en cuivre, mais aussi d'autre matériaux conducteurs, y compris des alliages.
Une entreprise américaine à quant à elle développé une technologie d'impression qui repose sur une polarisation sélective d'un réseau d'anode, ce qui permet d'imprimer Stéréo-électrochimiquement des pièces complexes en cuivre, avec comme application des refroidisseur haute performance pour processeur avec des structure en gyroides permettant de maximiser les échanges thermique. L'intérêt est que la performance des processeur est limité par la capacité à le refroidir.

Grace aux développements des Modèles de langage OpenSource notamment avec (Mixtral 8x7b) il a été facile de re-bricoler une imprimante résine avec une carte arduino pour l'interfacer avec un PC, les progrès sont tels que j'ai quasiment pas eu besoin d'utiliser ChatGPT 3.5.
 Théorie vs pratique
 gravure de l'or sur le PMMA
J'ai commencé par réaliser des essais sur du PMMA 3mm avec la Trotec Speedy 360 pour vérifier mon motif réalisé sur Kicad/Inkscape, j'ai notamment remarqué le manque de résolution pour des détail verticaux en balayage horizontale, dû à l'anisotropie du balayage de la graveuse laser. J'ai aussi essayer de réaliser la gravure à 45 degré, cela résous l'anisotropie, mais apporte les défauts à l'ensemble du dispositif. La solution serait de réaliser un balayage Vertical suivit d'un balayage horizontale sans avoir besoin de tourner la pièce manuellement(difficulté à l'aligner). J'ai contacté Le technicien commercial de Trotec qui m'a déconseillé de débloquer cette fonctionnalité. Il m'a en revanche conseillé de travailler avec une vitesse 4 fois inferieur avec une puissance proportionnellement plus faible pour augmenter par 8 la qualité. Le problème rencontré est notamment dû au temps de changement de la puissance du laser.

J'ai aussi noté l'impossibilité d'employer le contour par écriture direct en raison des trajectoires par acoup créant des trou profond et détruit les connections aux alentours. D'après le technicien commercial, il s'agit d'un problème lié à la correction de puissance. Il faudrait la diminuer? Eventuellement à essayer sur l'or?
Il m'a précisé qu'il n'est pas souhaité d'appeler le technicien commercial soi même, c'est le rôle du Fabmanager.

La speedy 360 et 100 possèdent un laser d'un laser d'une taille de point de 120µm et de longueure d'onde 10,6 µm (microonde). Il faut donc en tenir compte dans le design. j'ai donc retracer les contours sur inkscape pour tenir compte de la taille de point, avec en rouge le chemin du point de 120µm.

L'or présente une barrière d'activation avant la gravure, même si il semble exister une énergie intermédiaire pour seulement retirer en partie l'or d'une 100 aines de nanomètres, il est nécessaire d'utiliser une puissance beaucoup plus élevée, ce qui engendre des creux plus profond sur le PMMA.
Pour optimiser le processus en jouant sur la longueur d'onde il faut étudier l'absorbance du PMMA et de l'or qui sont tout deux assez mauvais. Ce qui explique bien ce phénomène.

Repousser les limites de la Speedy  360 à un intérêt pour la microfabrication en Makerspace, et permet d'avoir une résolution utilisable. Mais pour avoir une bonne répétabilité, il serait intéressant de pouvoir utiliser la LPKF Protolaser H4 qui offre une bien meilleure résolution. C'est pourquoi j'ai contacté LPKF qui m'ont confirmé la possibilité théorique d'utiliser d'autre matériaux sans risque particulier. Il ma notamment fournit un guide pour faire des tests afin de trouver les bon paramètres. Néanmoins il est nécessaire d'être formé à cette machine qui utilise un laser fibré de 1064 nm (IR) d'une taille de point de 25µm, et permet de réaliser un double balayage vertical et horizontal. Voici un lien du document en question : https://drive.google.com/file/d/1aiiEEKLoY4rNRjV9LAuTF24pEDxQzHwb/view?usp=sharing

Il sera envisagé d'utiliser cette machine pour la réalisation de PCB pour l'imprimante 3D ainsi que la réalisation des électrodes.
Le laser à une zone de balayage de 30x30mm (haute précision) et la possibilité de déplacer cette zone en XYZ(moyenne précision).

il est important que ces zones de balayage ne gènent pas le design en se décalant.
Ainsi en une après midi avec Emmanuel, nous avons pu réaliser ce réseau d'électrode en optimisant les paramètres. Il est notable que la LPKF laisse de joli paillette dans le PMMA qui n'est pas gravé du tout. Le matériaux a été paramètré comme un PCB de 3mm avec une couche de cuivre de 0.1 µm.(analogue à notre config) Il a été réalisé plusieurs test pour optimiser les paramètres afin d'avoir le résultat souhaité.

il a été remarqué que des détails en or ont été arraché, il a donc été important d'optimiser la puissance en la baissant pour ne pas déchirer l'or.

En optimisant les paramètres

il a été possible de se débarrasser au maximum des déchirure avec une puissance de 0.3W.
Il serait intéressant de changer de substrat pour avoir une meilleure adhésion comme par exemple un support de type pcb.
Titrage pH-mètrique

Nous avons réaliser un TP sur le titrage avec un pH-mètre, car nous avions commis une erreur lors de notre TP lors de notre TP de chimie. Pour cela nous avons réaliser un titrage à FABLAB en essayant de reproduire les mêmes condition qu'en TP, pou cela nous avons utiliser une solution de soude en tant que solution titrante de concentration connue (environ 1,04E-02 mol.L-1 (NAOH), et une solution à titrée  d'acide acétique (CH3COOH) de concentration connue (environ 1,03E-02 mol/L).

Le but de ce TP est de montrer comment la mesure du pH permet de déterminer un volume à l’équivalence sans utiliser d’indicateurs colorée.
Nous avons donc réaliser les étapes de base d'un titrage avec ajout de 0,2ml de soude si le résultat du calcul ∆pH/∆Vs était supérieur à 0,3 et +1 ml si le résultat était inférieur à 0,3.

Voici les résultats obtenue sous forme de tableau et de graphe

Les résultats obtenue ne sont pas ceux voulue, il  y a surement eu une erreur dans ce TP car il nous aurait fallu une courbe de ce type :

Ce TP nous a pas permis de résoudre le problème du premier TP mais il nous a permit de faire le TP à l'état brut avec une double dilution ( c'est-à-dire préparer nous même les condition de TP) et donc avoir une approche différente de ce TP.
On espère que ce petit compte rendu vous sera utile même si on en doute fort.

Journal des impressions

🎮 Électronique



Redressement de tensions alternatifs

L'objectif est de redresser des tensions alternatifs en tensions continues. Notre étude se restreindra à l'application d'un pont redresseur de tensions en monophasé. Nous verrons deux types principaux de redresseurs :

- le redresseur simple alternance
-le redresseur double alternance
Nous lisserons ensuite les tensions obtenues par un condensateur.

Schéma du montage : redresseur simple alternance
(sans lissage)                                                                                                             (avec lissage via condensateur)

Schéma du montage : redresseur double alternance
(sans filtrage)                                                                  (avec filtrage)

robot qui saute à 30 m


https://www.nature.com/articles/s41586-022-04606-3.epdf?sharing_token=iwOWfzCrg84fVTvPnzS6k9RgN0jAjWel9jnR3ZoTv0NoCvlhBLYcl3v5dmxMf_KV4fMB6StwnBM7o-Iccw29Ng5B50g02eXLxhfTQhAiolhV_TBnJLGKC0YfSS8TRmKCfqfqRa5EgTBkFBoWUbTd-BUujlkDe9M0ai02nX1zdA8%3D
https://www.youtube.com/redirect?event=video_description&redir_token=QUFFLUhqazlRcy1pRTV6bFZBYm5KSm1LcWtlaWc2Um1ad3xBQ3Jtc0tsSkViN3diSnRMWkhBTElPMk1qZkN3dktlbFlVN0hQSGVxbDN6Mkd5QUI2RURPQURYYk01WU9rdVZMOGZpV2lZWm1iRldrRlJiLS00QUlXVUMzRzJuTkVnbkdlR1RzYS1ldmJrZVZjeHpwU2NIdzdpNA&q=https%3A%2F%2Frdcu.be%2FcMePc&v=daaDuC1kbds
J'ai déjà fait quelques courses... je négocie de l'aide de la part de ISIR, et sinon je ferais entièrement avec le fablab.
J'ai les élastiques!Régulateur solaire MPTT

Schemas et PCB: https://github.com/mbouyer/canbus_solar_mppt
test de la carte de puissance
Pour les tests de la partie puissance sans la carte de contrôle j'ai utilisé les matériels suivants:

alimentation de laboratoire 10A (pour l'entrée solar_in)
générateur de fonction, pour générer le signal PWM
alimentation de laboratoire pour founir le 5V

multimètre (pour mesure précise de la tension d'entrée)
multimètre de table (pour mesure précise du courant d'entrée)
charge fictive (pour consomer le courant en sortie, à courant constant)
oscilloscope (pour visualiser les différent signaux)

Il est ainsi possible de faire varier les différent paramètres (tension d'entrée, rapport de cycle, courant de sortie) et mesurer l'efficacité du convertisseur (c'est a dire le rapport puissance de sortie/puissance d'entrée).
Lors des premier tests plusieurs disfonctionnement sont apparus, qui ont fini par griller plusieurs composants, rendant la carte non-fonctionelle. Je pense que la cause principale est la sur-oscillation qui se produit au noeud SW, en particulier lorsque le mosfet haut devient passant, causant un pic transitoire de surtension (visible sur le grahe violet ci dessous) que j'ai sous-estimé.

Pour atténuer cette sur-oscillation, plusieurs modifications ont été apportées:

Re-routage du circuit pour que les masses des condensateurs d'entrée (c3 à c7 sur le nouveau schema) soient du même coté que les masses des condensateurs de sortie et que le transistor bas du convertisseur (le chemin pour rejoindre la masse de ces condensateurs était beaucoup trop long !)
ajout d'une resistance en série avec le condensateur boost pour ralentir le front montant du transistor haut (avec une diode en parallèle pour changer le condensateur plus rapidement si nécessaire)
ajout d'un filtre RC sur le noeud SW

Les valeurs de ces composants seront à déterminer par mesure sur le circuit
D'autre part les drivers DGD0215 ont eu un comportement problématique (qui peut apparaitre à la mise sous tension), ou ils peuvent réinjecter leur tension d'alimentation sur leur entrée IN (qui qui a conduit à une surtention de l'alimentation 5V et la destruction du PAC1953). Pour tenter de limiter cela, j'ai ajouté un transistor MOS entre les DGD0215 et les commandes.
Lors du test de la seconde carte, il apparait que lors de la mise sous tension des DGD0215 les transistors Q3 à Q6 sont brièvement passants (voir restent bloqués dans l'état passant). Il semble donc que ces drivers ne soient pas adaptés à cette application. Je les ai donc supprimés et pilote les grilles des mosfet P directement avec les transistors BSS123. Du fait de la résistance de pullup (rédite à 10K) les comutations seront plus lentes, mais cela peut être géré en logiciel au niveau de la carte de contrôle.simulateur de panneau solaire

La courbe tension/courant d'un paneau solaire est celle ci:

Un panneau solaire se comporte comme un générateur de courant constant, avec une zone de transition pour les courants faibles due aux diodes en série. Plus de détails sur cette page: https://solarpost.in/basics/i-v-curve-solar-pv/
Pour le projet Régulateur solaire MPTT j'ai besoin d'une alimentation simulant un panneau solaire pour mettre au point l'agorithme MPTT. Une simple alimentation de laboratoire en courant constant a un comportement trop «carré» pour cela; de plus les alimentation à découpage présentent des impulsions lors de la limitation de courant qui, lorsque l'on travaille sous courant élevé, peuvent être destructeur. L'idée est donc de réaliser une source de courant constant qui réponde au besoin.

Le courant est limité par le transistor de puissance Q2, monté en darlington avec Q1. Le courant est mesuré aux bornes de la résistance R3. R1, D1 et RV1 fournissent une référence de tension ajustable. L'amplificateur operationel U1 compare la tension aux bornes de R3 avec la référence sur son entrée «+» et sa sortie pilote le transistor de puissance. Pour les courants faibles, Q2 devrait être passant mais le montage darlington impose une chute de tension minimale pour saturer Q2, donnant a l'ensemble un comportement plus linéaire.
Pour R3 nous n'avons pas en stock de résistance de puissance de si faible valeur. Mais nous avons une bobine de fil de cuivre pour lequel le fournisseur donne les caractéristiques; en particulier sa résistance: 183 ohms par Km. 1 mètre de ce cable donnera donc une résistance d'environ 183 mOhms (nous n'avont pas besoin d'une valeur très précise ici; RV1 nous permettra d'ajuster le courant).
Le montage est réalisé sur une breadboard; le transistor de puissance Q2 est monté sur un radiateur pour évacuer la chaleur.

Pour caractériser le montage nous utilisons une alimentation de laboratoire pouvant founir plusieurs ampères sous 25V, et une charge fictive Charge électronique TENMA 72-13210. Cette dernière sera utilisée en tension constante (ce qui veut dire qu'elle consome le courant nécessaire pour atteindre la tension de consigne), en faisant varier le réglage de la tension et en mesurant le courant nous obtenons la courbe I/V du montage.
Cet appareil peut être connecté à un ordinateur par USB, qui pourra alors le piloter et récupŕer les valeur mesurées. L'appareil est vu comme un pont USB/série sur le PC. il envoie ses commandes sous forme de chaine de caractère, et obtient les réponses sous forme de chaine de caractère également (se reporter aux documentations sur la page Charge électronique TENMA 72-13210). Nous allons donc utiliser un script (en perl) pour réaliser les mesures:

#!/usr/pkg/bin/perl

use Device::SerialPort;
use Time::HiRes qw( usleep );

my $line;
my $port = Device::SerialPort->new($ARGV[0]) or die "failed to open serial port";
$port->databits(8);
$port->baudrate(115200);
$port->parity("none");
$port->stopbits(1);

$port->write("*IDN?\n");
$line = getportln($port);
print ("IDN: $line\n");

my $setvolt=24;

$port->write(":FUNC CV\n");
setvolt($port, $setvolt);
$port->write(":INP ON\n");

while ($setvolt >= 10)
{
 setvolt($port, $setvolt);
 $setvolt = $setvolt - 0.1;
}
$port->write(":INP OFF\n");

exit(0);

sub setvolt
{
 my ($p, $v) = @_;
 $p->write(":VOLT " . $v . "V\n");
 $p->write(":VOLT?\n");
 my $l = getportln($p);
 print("set $l");
 usleep(500000);
 $p->write(":MEAS:CURR?\n");
 $l = getportln($p);
 print(" $l ");
 $p->write(":MEAS:VOLT?\n");
 $l = getportln($p);
 print(" $l\n");
}

sub getportln
{
 my ($p) = @_;
 my $l = "";
 while(1) {
 my $byte = $port->read(1);
 if ($byte eq "\n") {
 $p->lookclear;
 return $l;
 }
 $l = $l . $byte;
 }
}

La commande *IDN? permet de vérifier la communication avec l'appareil. Ensuite nous réglons la consigne à 24V puis activons la charge fictive. ensuite, pour chaque valeur de 24V à 10V (par pas de 0,1V) la consigne est envoyée à l'appareil, et après une attente de 500ms les valeurs mesurées de tension et intensité sont récupérées (cela se passe dans la routine setvolt). Enfin l'appareil est désactivé avant la fin du programme.
L'exécution donne: 
IDN: TENMA 72-13210 V2.10 S50011730
set 24.000V 0.0000A 24.407V
set 24.000V 0.0000A 23.998V
set 23.900V 0.0000A 23.896V
set 23.800V 0.0000A 23.796V
set 23.700V 0.0047A 23.698V
set 23.600V 0.0160A 23.598V
set 23.500V 0.0382A 23.496V
set 23.400V 0.0699A 23.397V
set 23.300V 0.1103A 23.296V
set 23.200V 0.1546A 23.198V
set 23.100V 0.2049A 23.096V
set 23.000V 0.2572A 22.996V
set 22.900V 0.3104A 22.895V
set 22.800V 0.3645A 22.796V
set 22.700V 0.4185A 22.698V
set 22.600V 0.4733A 22.598V
set 22.500V 0.5278A 22.499V
set 22.400V 0.5821A 22.398V
set 22.300V 0.6363A 22.299V
set 22.200V 0.6915A 22.197V
set 22.100V 0.7435A 22.099V
set 22.000V 0.7974A 21.998V
set 21.900V 0.8490A 21.900V
set 21.800V 0.9019A 21.797V
set 21.700V 0.9536A 21.697V
set 21.600V 1.0035A 21.599V
set 21.500V 1.0540A 21.499V
set 21.400V 1.1048A 21.397V
set 21.300V 1.1538A 21.297V
set 21.200V 1.2032A 21.196V
set 21.100V 1.2502A 21.099V
set 21.000V 1.2986A 20.998V
set 20.900V 1.3457A 20.898V
set 20.800V 1.3929A 20.797V
set 20.700V 1.4395A 20.698V
set 20.600V 1.4864A 20.596V
set 20.500V 1.5310A 20.498V
set 20.399V 1.5769A 20.397V
set 20.299V 1.6215A 20.298V
set 20.199V 1.6672A 20.195V
set 20.099V 1.7112A 20.095V
set 19.999V 1.7546A 19.996V
set 19.899V 1.7979A 19.896V
set 19.799V 1.8412A 19.797V
set 19.699V 1.8841A 19.696V
set 19.599V 1.9263A 19.596V
set 19.499V 1.9680A 19.498V
set 19.399V 2.0100A 19.397V
set 19.299V 2.0521A 19.297V
set 19.199V 2.0936A 19.196V
set 19.099V 2.1345A 19.096V
set 18.999V 2.1762A 18.996V
set 18.899V 2.2157A 18.897V
set 18.799V 2.2565A 18.796V
set 18.699V 2.2964A 18.698V
set 18.599V 2.3367A 18.595V
set 18.499V 2.3766A 18.495V
set 18.399V 2.4148A 18.396V
set 18.299V 2.4543A 18.296V
set 18.199V 2.4935A 18.197V
set 18.099V 2.5313A 18.097V
set 17.999V 2.5704A 17.996V
set 17.899V 2.6074A 17.899V
set 17.799V 2.6465A 17.796V
set 17.699V 2.6846A 17.696V
set 17.599V 2.7219A 17.595V
set 17.499V 2.7594A 17.496V
set 17.399V 2.7967A 17.394V
set 17.299V 2.8319A 17.297V
set 17.199V 2.8357A 17.196V
set 17.099V 2.8391A 17.097V
set 16.999V 2.8410A 16.994V
set 16.899V 2.8443A 16.895V
set 16.799V 2.8479A 16.795V
set 16.699V 2.8502A 16.696V
set 16.599V 2.8547A 16.597V
set 16.499V 2.8580A 16.496V
set 16.399V 2.8623A 16.397V
set 16.299V 2.8651A 16.302V
set 16.199V 2.8688A 16.201V
set 16.099V 2.8732A 16.099V
set 15.999V 2.8777A 16.001V
set 15.899V 2.8828A 15.899V
set 15.799V 2.8869A 15.802V
set 15.699V 2.8913A 15.700V
set 15.599V 2.8966A 15.600V
set 15.499V 2.9011A 15.500V
set 15.399V 2.9062A 15.399V
set 15.299V 2.9112A 15.298V
set 15.199V 2.9154A 15.201V
set 15.099V 2.9199A 15.099V
set 14.999V 2.9236A 15.000V
set 14.899V 2.9277A 14.899V
set 14.799V 2.9312A 14.799V
set 14.699V 2.9345A 14.701V
set 14.599V 2.9385A 14.600V
set 14.499V 2.9426A 14.498V
set 14.399V 2.9466A 14.398V
set 14.299V 2.9499A 14.298V
set 14.199V 2.9532A 14.200V
set 14.099V 2.9572A 14.099V
set 13.999V 2.9606A 13.999V
set 13.899V 2.9642A 13.899V
set 13.799V 2.9661A 13.798V
set 13.699V 2.9683A 13.698V
set 13.599V 2.9723A 13.599V
set 13.499V 2.9769A 13.499V
set 13.399V 2.9820A 13.400V
set 13.299V 2.9866A 13.299V
set 13.199V 2.9903A 13.199V
set 13.099V 2.9940A 13.101V
set 12.999V 2.9972A 13.000V
set 12.899V 3.0006A 12.899V
set 12.799V 3.0025A 12.798V
set 12.699V 3.0055A 12.698V
set 12.599V 3.0090A 12.600V
set 12.499V 3.0120A 12.498V
set 12.399V 3.0176A 12.398V
set 12.299V 3.0203A 12.299V
set 12.199V 3.0236A 12.198V
set 12.099V 3.0270A 12.098V
set 11.999V 3.0301A 11.999V
set 11.899V 3.0339A 11.899V
set 11.799V 3.0392A 11.800V
set 11.699V 3.0455A 11.697V
set 11.599V 3.0495A 11.598V
set 11.499V 3.0538A 11.500V
set 11.399V 3.0584A 11.399V
set 11.299V 3.0622A 11.298V
set 11.199V 3.0652A 11.198V
set 11.099V 3.0684A 11.097V
set 10.999V 3.0710A 11.000V
set 10.899V 3.0740A 10.897V
set 10.799V 3.0765A 10.797V
set 10.699V 3.0783A 10.698V
set 10.599V 3.0806A 10.598V
set 10.499V 3.0826A 10.499V
set 10.399V 3.0850A 10.399V
set 10.299V 3.0871A 10.300V
set 10.199V 3.0892A 10.200V
set 10.099V 3.0918A 10.100V

Ce fichier pemet de tracer la courbe V/I, par exemple avec gnuplot:

L'ensemble des fichiers sont disponibles dans emulsp.zipProjet Ventilateur Grow Box

Dans ce projet on cherche a répondre a un problème qui est la surchauffe de panneau LED dans un Grow Box à l'espace Greenlab. Pour y remédier, le but est de créer un programme sur un Arduino UNO qui va permettre d'activer un ventilateur lorsque la température est trop élevé. Pour l'instant j'ai un schéma de montage avec une carte Arduino UNO branché à un capteur de température qui, en fonction de la température, vas ouvrir ou fermer un relai ce qui aura pour effet d'ouvrir ou de fermer le circuit du ventilateur. Le code que j'ai utilisé est le suivant :
#include <Adafruit_Sensor.h>
#include <DHT.h>
#define DHTpin 2             // pin2 devient le pin du DHT11
#define Relai 3                // pin3 devient le pin du relai
#define DHTTYPE DHT22          // on règle le modèle de capteur
DHT dht(DHTpin, DHTTYPE);

void setup() {

 pinMode(DHTpin, INPUT);       // règle le pin 2 en input

 pinMode(Relai, OUTPUT);      // règle le pin 3 en output

 Serial.begin(9600);          // initialise la comm.

 dht.begin();                 // allume le capteur
}

void loop() {

 delay(2000);                       //attend un peu entre chaque mesures

 float t = dht.readTemperature();   // lit la température exterieur et l'associe à la variable t=température

 if ( t >= 25 ) {                    // si la temérature est au dessus de 35°C

   digitalWrite(Relai, HIGH);      // le relai se ferme => le ventilateur s'allume

   Serial.println("closed");

 }

 else {                            // la température est a 35°C ou moins

   digitalWrite(Relai, LOW);       // le relai s'ouvre => le ventilateur s'arrête

   Serial.println("open");

 }

 if (isnan(t)) {

   Serial.println("x(");           // verifie le bon fonctionnement du capteur

 }

 Serial.println(t);
}

Maintenant, il ne reste plus qu'a rajouter des fonctionnalités tels qu'un écran LCD avec possibilité de régler la température de déclenchement, mais aussi des moyens de régler l'hygrométrie !!
J'ai ajouté ci-joint les librairies utilisé dans ce code.
Paul SPIRCKEL : J'ai ajouté un LCD (https://learn.adafruit.com/character-lcds/wiring-a-character-lcd). A chaque déclenchement du relais, il est parasité par de nombreux de caractères mais le circuit fonctionne toujours en arrière-plan.
A noter qu'il faudrait ajouter un petit delta de température de façon à ce que le ventilateur ne s'active/désactive pas sans arrêt autour de 25°C (typiquement ventiler jusqu'à 22°C avant de se désactiver).
Voici le code mis à jour :

#include <Adafruit_Sensor.h>

#include <DHT.h>

#include <LiquidCrystal.h>

#define DHTpin 2 // pin2 devient le pin du DHT11

#define Relai 3 // pin3 devient le pin du relai

#define DHTTYPE DHT22 // on règle le modèle de capteur

DHT dht(DHTpin, DHTTYPE);

LiquidCrystal lcd(7, 8, 9, 10, 11, 12); // connexion des ports de l'écran LCD

void setup() {

 pinMode(DHTpin, INPUT); // règle le pin 2 en input

 pinMode(Relai, OUTPUT); // règle le pin 3 en output

 Serial.begin(9600); // initialise la comm.

 dht.begin(); // allume le capteur

 lcd.begin(16, 2);

 lcd.setCursor(1, 0);

 lcd.write("Temperature =");

 lcd.setCursor(6, 1);

 lcd.write(" C");

 
}

void loop() {

 delay(2000); //attend un peu entre chaque mesures

 float t = dht.readTemperature(); // lit la température exterieur et l'associe à la variable t=température

 lcd.setCursor(0, 1);

 lcd.print(dht.readTemperature());
 

 if ( t <= 25 ) { // si la temérature est au dessus de 35°C

 digitalWrite(Relai, HIGH); // le relai se ferme => le ventilateur s'allume

 Serial.println("closed");

 }

 else { // la température est a 35°C ou moins

 digitalWrite(Relai, LOW); // le relai s'ouvre => le ventilateur s'arrête

 Serial.println("open");

 }

 if (isnan(t)) {

 Serial.println("x("); // verifie le bon fonctionnement du capteur

 }

 Serial.println(t);

 

 }
Paul SPIRCKEL : J'ai finalisé le code pour 1 ventilateur, avec un delta de température de 3°C et un potentiomètre permettant de choisir le seuil de température à ne pas dépasser. Le LCD ne fonctionne toujours pas correctement. Il peut s'agir d'un problème matériel donc je n'ai rien changé tant que le circuit ne sera pas posé sur une platine. Aussi, il faut faire attention à ne pas allumer le circuit avec le potentiomètre réglé pour une température en dessous de la température ambiante sinon le ventilateur ne s'arrêtera jamais de tourner. Si c'est le cas, il faut juste éteindre le circuit, remonté le potentiomètre et tout rallumer.
#include <Adafruit_Sensor.h>

#include <DHT.h>

#include <LiquidCrystal.h>

#define DHTpin 2 // pin2 devient le pin du DHT11

#define Relai 3 // pin3 devient le pin du relai

#define DHTTYPE DHT22 // on règle le modèle de capteur

DHT dht(DHTpin, DHTTYPE);

LiquidCrystal lcd(7, 8, 9, 10, 11, 12); // connexion des ports de l'écran LCD

int adcPin = A0; // attribution du pin analogique A0 comme entrée du signal du potentiomètre
int poten = 0; // poten est la variable modifiée par le potentiomètre

void setup() {

 pinMode(DHTpin, INPUT); // règle le pin 2 en input

 pinMode(Relai, OUTPUT); // règle le pin 3 en output

 pinMode(adcPin, INPUT); // règle le pin A0 (analogique) comme entrée du signal du potentiomètre

 Serial.begin(9600); // initialise la comm.

 dht.begin(); // allume le capteur
 
 lcd.begin(16, 2);

 lcd.setCursor(0, 0);

 lcd.println("Temp =");

 lcd.setCursor(0, 1);

 lcd.println("Set = ");

 
}

void loop() {

 delay(2000); //attend un peu entre chaque mesures

 poten = (analogRead(adcPin)/10); // poten prend comme valeur celle envoyée par le potentiomètre, divisée par 10 pour avoir un interval de température entre 0 et 70°C

 Serial.println(3+poten); // on fixe une valeur minimum de T à 3°C de façon à créer un delta en additionnant la valeur poten

 lcd.setCursor(6, 1);

 lcd.println(3+poten);

 if ( dht.readTemperature() >= (3+poten) ) { // si la température est au dessus de (3+poten)

 while (dht.readTemperature() >= (poten)) { // et tant qu'elle n'est pas repassée en dessous de poten (donc 3°C en dessous de la valeur de déclenchement), on active le ventilateur 

 delay(2000);
 
 digitalWrite(Relai, LOW); // le relai se ferme => le ventilateur s'allume

 Serial.println(dht.readTemperature());
 
 Serial.println("closed");

 lcd.setCursor(7, 0);

 lcd.write(dht.readTemperature());

 }

 }

 else { // la température est a 35°C ou moins

 digitalWrite(Relai, HIGH); // le relai s'ouvre => le ventilateur s'arrête

 Serial.println(dht.readTemperature());

 Serial.println("open");

 lcd.setCursor(7, 0);

 lcd.write(dht.readTemperature());

 }

}

Avec 2 relais
#include <Adafruit_Sensor.h>

#include <DHT.h>

#include <LiquidCrystal.h>

#define DHTpin 2 // pin2 devient le pin du DHT11

#define Relai_1 3 // pin3 devient le pin du relai 1

#define Relai_2 4 // pin4 devient le pin du relai 2

#define DHTTYPE DHT22 // on règle le modèle de capteur

DHT dht(DHTpin, DHTTYPE);

LiquidCrystal lcd(7, 8, 9, 10, 11, 12); // connexion des ports de l'écran LCD

int adcPin = A0; // attribution du pin analogique A0 comme entrée du signal du potentiomètre
int poten = 0; // poten est la variable modifiée par le potentiomètre

void setup() {

 pinMode(DHTpin, INPUT); // règle le pin 2 en input

 pinMode(Relai_1, OUTPUT); // règle le pin 3 en output

 pinMode(Relai_2, OUTPUT); // règle le pin 4 en output

 pinMode(adcPin, INPUT); // règle le pin A0 (analogique) comme entrée du signal du potentiomètre

 Serial.begin(9600); // initialise la comm.

 dht.begin(); // allume le capteur
 
 lcd.begin(16, 2);

 lcd.setCursor(0, 0);

 lcd.println("Temp =");

 lcd.setCursor(0, 1);

 lcd.println("Set = ");

 
}

void loop() {

 delay(2000); //attend un peu entre chaque mesures

 poten = (analogRead(adcPin)/10); // poten prend comme valeur celle envoyée par le potentiomètre, divisée par 10 pour avoir un interval de température entre 0 et 70°C

 Serial.println(3+poten); // on fixe une valeur minimum de T à 3°C de façon à créer un delta en additionnant la valeur poten

 lcd.setCursor(6, 1);

 lcd.println(3+poten);

 if ( dht.readTemperature() >= (3+poten) ) { // si la température est au dessus de (3+poten)

 while (dht.readTemperature() >= (poten)) { // et tant qu'elle n'est pas repassée en dessous de poten (donc 3°C en dessous de la valeur de déclenchement), on active le ventilateur 

 delay(2000);
 
 digitalWrite(Relai_1, LOW); // le relai se ferme => le ventilateur s'allume

 Serial.println(dht.readTemperature());
 
 Serial.println("closed 1");

 lcd.setCursor(7, 0);

 lcd.write(dht.readTemperature());

 while (dht.readTemperature() >= (poten+2)) { // et tant qu'elle n'est pas repassée en dessous de poten (donc 3°C en dessous de la valeur de déclenchement), on active le ventilateur 

 delay(2000);
 
 digitalWrite(Relai_2, LOW); // le relai se ferme => le ventilateur s'allume

 Serial.println(dht.readTemperature());
 
 Serial.println("closed 2");

 }

 }

 }

 else { // la température est a 35°C ou moins

 digitalWrite(Relai_1, HIGH); // le relai s'ouvre => le ventilateur s'arrête

 Serial.println(dht.readTemperature());

 Serial.println("open");

 lcd.setCursor(7, 0);

 lcd.write(dht.readTemperature());

 }

}
Miro Von der Borch : J'ai aujourd'hui tenté de résoudre certains problèmes de la version précédente du code et du montage :
-Des bugs d'affichage sur l'écran LDC
-La communication serial qui ne renvoie rien
-La valeur des potentiomètres qui se fige si elle est en dessous de la température
Une première modification que j'ai apporté a été de brancher le file de contraste directement à la masse pour se débarrasser d'un des potentiomètres inutile. Ensuite, j'ai modifier le code à deux relais en ajoutant des espaces à la fin de chaque print du LCD ce qui a corrigé l'un des bugs d'affichage, mais pas le second qui fait que la première valeur de température du capteur DHT est un caractère étrange. J'ai aussi ajouté des actualisation au sein de chaque "while" de la valeur "poten" :
#include <Adafruit_Sensor.h>

#include <DHT.h>

#include <LiquidCrystal.h>

#define DHTpin 2 // pin2 devient le pin du DHT11

#define Relai_1 3 // pin3 devient le pin du relai 1

#define Relai_2 4 // pin4 devient le pin du relai 2

#define DHTTYPE DHT22 // on règle le modèle de capteur

DHT dht(DHTpin, DHTTYPE);

LiquidCrystal lcd(7, 8, 9, 10, 11, 12); // connexion des ports de l'écran LCD

int adcPin = A0; // attribution du pin analogique A0 comme entrée du signal du potentiomètre
int adcPinfine = A1; // attribution du pin analogique A1 comme entrée su signal du potentiomètre de réglage fin
int poten = 0; // poten est la variable modifiée par les potentiomètres

void setup() {

 pinMode(DHTpin, INPUT); // règle le pin 2 en input

 pinMode(Relai_1, OUTPUT); // règle le pin 3 en output

 pinMode(Relai_2, OUTPUT); // règle le pin 4 en output

 pinMode(adcPin, INPUT); // règle le pin A0 (analogique) comme entrée du signal du potentiomètre

 Serial.begin(9600); // initialise la comm.

 dht.begin(); // allume le capteur
 
 lcd.begin(16, 2);

 lcd.setCursor(0, 0);

 lcd.println("Temp = ");

 lcd.setCursor(0, 1);

 lcd.println("Set = ");

 
}

void loop() {

 delay(2000); //attend un peu entre chaque mesures

 poten = ((7+analogRead(adcPin)/40)+(analogRead(adcPinfine)/125)); // poten prend comme valeur celle envoyée par le potentiomètre, divisée par 10 pour avoir un interval de température entre 0 et 70°C à laquelle on ajoutte celle d'un deuxième potentiomètre divisé par 100 pour avoir plus de précision

 Serial.println(3+poten); // on fixe une valeur minimum de T à 3°C de façon à créer un delta en additionnant la valeur poten

 lcd.setCursor(7, 0);

 lcd.println(dht.readTemperature());

 lcd.setCursor (12, 0);

 lcd.println(" C ");

 lcd.setCursor (7, 1);

 lcd.println(3+poten);

 lcd.setCursor (9, 1);

 lcd.println (" C ");

 if ( dht.readTemperature() >= (3+poten) ) { // si la température est au dessus de (3+poten)

 while (dht.readTemperature() >= (poten)) { // et tant qu'elle n'est pas repassée en dessous de poten (donc 3°C en dessous de la valeur de déclenchement), on active le ventilateur 

 delay(2000);
 
 digitalWrite(Relai_1, LOW); // le relai se ferme => le ventilateur s'allume

 Serial.println(dht.readTemperature());
 
 Serial.println("closed 1");

 lcd.setCursor(7, 0);

 lcd.println(dht.readTemperature());

 lcd.setCursor (12, 0);

 lcd.println(" C "); // après chaque print de l'écran LCD j'ai rajouter une instruction pour afficher d'une part l'unité mais aussi pour se débarrasser les symboles étranges qui apparraissaient à la fin des print

 poten = ((7+analogRead(adcPin)/40)+(analogRead(adcPinfine)/125)); // Ici j'ai ajouté une actualisation de la valeure poten afin d'éviter que la valeur ne se fige

 lcd.setCursor (7, 1);

 lcd.println(3+poten);

 lcd.setCursor (9, 1);

 lcd.println (" C ");

 while (dht.readTemperature() >= (poten+2)) { // et tant qu'elle n'est pas repassée en dessous de poten (donc 3°C en dessous de la valeur de déclenchement), on active le ventilateur 

 delay(2000);
 
 digitalWrite(Relai_2, LOW); // le relai se ferme => le ventilateur s'allume

 Serial.println(dht.readTemperature());
 
 Serial.println("closed 2");
 
 lcd.setCursor(7, 0);

 lcd.println(dht.readTemperature());

 lcd.setCursor (12, 0);

 lcd.println(" C ");

 poten = ((7+analogRead(adcPin)/40)+(analogRead(adcPinfine)/125));

 lcd.setCursor (7, 1);

 lcd.println(3+poten);

 lcd.setCursor (9, 1);

 lcd.println (" C ");

 }

 }

 }

 else { // la température est a 35°C ou moins

 digitalWrite(Relai_1, HIGH); // le relai s'ouvre => le ventilateur s'arrête

 Serial.println(dht.readTemperature());

 Serial.println("open");

 lcd.setCursor(7, 0);

 lcd.write(dht.readTemperature());

 }

}

Je n'ai cependant pas réussi à faire fonctionner la communication sérial.
Pour le bug d'affichage de la valeur de température du DHT, il n'est pas toujours présent, notamment, l'affichage se fait correctement si les relais sont éteint (le circuit est fermé). Je suspect donc que le problème viens du fait que les relais sont sur la même alimentation que l'écran. Piste à creuser...
Paul SPIRCKEL :
J'ai continué à améliorer le code. J'ai notamment essayé de modifier les boucles while car lorsque la condition n'est plus valide, les signaux déclarés en LOW ne repassent pas en HIGH. Pour ce faire il faut écrire quelque part "digitalWrite(Relai_..., HIGH)". Ainsi plutôt que d'imbriquer 2 boucles while, j'ai essayé de faire démarrer les deux ventilateurs tant que la température n'était pas redescendue en dessous de (2+poten) et une fois sorti de la boucle, que le relai 2 s'ouvre mais que le premier reste bien fermé jusqu'à ce que le if ne soit plus vrai. Un deuxième problème s'est alors posé, la sortie d'une boucle while comprise dans un if renvoie immédiatement au else. Même en essayant de mettre un deuxième while dans le if (pour T < (2+poten), les deux ventilateurs s'éteignent immédiatement.
Ce code n'est clairement pas abouti

#include <Adafruit_Sensor.h>

#include <DHT.h>

#include <LiquidCrystal.h>

#define DHTpin 2 // pin2 devient le pin du DHT11

#define Relai_1 4 // pin3 devient le pin du relai 1

#define Relai_2 5 // pin4 devient le pin du relai 2

#define DHTTYPE DHT22 // on règle le modèle de capteur

DHT dht(DHTpin, DHTTYPE);

LiquidCrystal lcd(7, 8, 9, 10, 11, 12); // connexion des ports de l'écran LCD

int adcPin = A0; // attribution du pin analogique A0 comme entrée du signal du potentiomètre
int adcPinfine = A1; // attribution du pin analogique A1 comme entrée su signal du potentiomètre de réglage fin
int poten = 0; // poten est la variable modifiée par les potentiomètres

void setup() {

 pinMode(DHTpin, INPUT); // règle le pin 2 en input

 pinMode(Relai_1, OUTPUT); // règle le pin 3 en output

 pinMode(Relai_2, OUTPUT); // règle le pin 4 en output

 pinMode(adcPin, INPUT); // règle le pin A0 (analogique) comme entrée du signal du potentiomètre

 Serial.begin(9600); // initialise la comm.

 dht.begin(); // allume le capteur
 
 lcd.begin(16, 2);

 lcd.setCursor(0, 0);

 lcd.println("Temp = ");

 lcd.setCursor(0, 1);

 lcd.println("Set = ");

 
}

void loop() {

 delay(2000); //attend un peu entre chaque mesures

 poten = ((7+analogRead(adcPin)/40)+(analogRead(adcPinfine)/125)); // poten prend comme valeur celle envoyée par le potentiomètre, divisée par 10 pour avoir un interval de température entre 0 et 70°C à laquelle on ajoutte celle d'un deuxième potentiomètre divisé par 100 pour avoir plus de précision

 Serial.println(3+poten); // on fixe une valeur minimum de T à 3°C de façon à créer un delta en additionnant la valeur poten

 lcd.setCursor(7, 0);

 lcd.println(dht.readTemperature());

 lcd.setCursor (12, 0);

 lcd.println(" C ");

 lcd.setCursor (7, 1);

 lcd.println(3+poten);

 lcd.setCursor (9, 1);

 lcd.println (" C ");

 if ( dht.readTemperature() >= (3+poten) ) { // si la température est au dessus de (3+poten)

 delay(2000); 

 Serial.println(dht.readTemperature());
 
 Serial.println("closed 1");
 
 lcd.setCursor(7, 0);

 lcd.println(dht.readTemperature());

 lcd.setCursor (12, 0);

 lcd.println(" C ");

 poten = ((7+analogRead(adcPin)/40)+(analogRead(adcPinfine)/125));

 lcd.setCursor (7, 1);

 lcd.println(3+poten);

 lcd.setCursor (9, 1);

 lcd.println (" C ");

 do {
 
 delay(2000);
 
 digitalWrite(Relai_1, LOW);
 digitalWrite(Relai_2, LOW);
 
 Serial.println(dht.readTemperature());
 
 Serial.println("closed 1 & 2");
 
 lcd.setCursor(7, 0);
 
 lcd.println(dht.readTemperature());
 
 lcd.setCursor (12, 0);
 
 lcd.println(" C "); // après chaque print de l'écran LCD j'ai rajouter une instruction pour afficher d'une part l'unité mais aussi pour se débarrasser des symboles étranges qui apparraissaient à la fin des print
 
 poten = ((7+analogRead(adcPin)/40)+(analogRead(adcPinfine)/125)); // Ici j'ai ajouté une actualisation de la valeure poten afin d'éviter que la valeur ne se fige
 
 lcd.setCursor (7, 1);
 
 lcd.println(3+poten);
 
 lcd.setCursor (9, 1);
 
 lcd.println (" C ");

 }
 while (dht.readTemperature() >= (2+poten)); // et tant qu'elle n'est pas repassée en dessous de poten (donc 3°C en dessous de la valeur de déclenchement), on active le ventilateur 

 do {
 
 delay(2000);
 
 digitalWrite(Relai_2, HIGH);
 
 Serial.println(dht.readTemperature());
 
 Serial.println("closed 1 & open 2");
 
 lcd.setCursor(7, 0);
 
 lcd.println(dht.readTemperature());
 
 lcd.setCursor (12, 0);
 
 lcd.println(" C "); // après chaque print de l'écran LCD j'ai rajouter une instruction pour afficher d'une part l'unité mais aussi pour se débarrasser des symboles étranges qui apparraissaient à la fin des print
 
 poten = ((7+analogRead(adcPin)/40)+(analogRead(adcPinfine)/125)); // Ici j'ai ajouté une actualisation de la valeure poten afin d'éviter que la valeur ne se fige
 
 lcd.setCursor (7, 1);
 
 lcd.println(3+poten);
 
 lcd.setCursor (9, 1);
 
 lcd.println (" C ");
 
 }

 while (dht.readTemperature() < (2+poten)); // et tant qu'elle n'est pas repassée en dessous de poten (donc 3°C en dessous de la valeur de déclenchement), on active le ventilateur 

 }

 else { // la température est à (3+poten) ou moins

 digitalWrite(Relai_1, HIGH); // le relai 1 s'ouvre => le ventilateur 1 s'arrête
 digitalWrite(Relai_2, HIGH); // le relai 2 s'ouvre => le ventilateur 2 s'arrête

 Serial.println(dht.readTemperature());

 Serial.println("open");

 lcd.setCursor(7, 0);

 lcd.write(dht.readTemperature());

 }

}

Miro VON DER BORCH (24/11/2023) :
J'ai reproduit le circuit à l'identique dans l'espace prototypage pour pouvoir continuer à avancer dessus. Je l'ai mis dans un des grands bacs en plastique en bas de l'étagère des projets. J'ai ainsi apporté les modifications suivantes au circuit :

J'ai abandonné le capteur DHT trop peu précis (plusieurs degrés d'incertitude) pour un capteur SHT31 bien plus précis (incertitude de l'ordre du dixième de degré à présent). Cependant, il n'apparait pas dans le montage ci-dessous car il se branche pour l'instant sur un shield seeeduino via les port I2C. Mais s'il existe un moyen de contourner le shield je suis preneur.
J'ai échangé les "slide potentiometer" de chez Arduino pour des potentiomètres rotatif plus précis (8 et 10kOHm) et plus esthétique aussi ! Seulement pour cela j'ai dût ajouter quelques résistances pour éviter tout risque de cours circuit.
J'ai aussi ajouté trois relais supplémentaire.

Un qui actionnerais une résistance de chauffe afin d'élever la température de la serre au dessus de la température ambiante.
Un autre qui actionnerais un système de refroidissement (une pompe à eau par exemple).
Un dernier qui actionnerais un système de brumisation afin de pouvoir contrôler l'hygrométrie à terme !

J'ai aussi remis un tout petit potentiomètre pour la luminosité (c'est finalement plus agréable).

J'ai aussi fait un premier aperçut du circuit imprimé que l'on pourrais faire pour ce montage avec toute les modifications que j'ai mentionné plus haut incluse dedans :

Le schéma du circuit sur KiCad

La PCB
J'ai joins le fichier de la PCB
Pour ce qui est du code :

Il faudra maintenant apporter quelques modifications pour l'adapter à la librairie du capteur SHT31 (essentiellement changer les "dht.read" par des "sht.get").
J'ai connecté

"résistance de chauffe" -----> pin digitale 5

"cooler" ---------------------> pin digitale 6
"système d'humidification" -> pin digital 13

Il faudrait établir des conditions d'allumage des nouveaux système lié à la régulation de la température, à savoir, le chauffage et le refroidissement actif.
Il faudrait établir un système de régulation de l'humidité (quand allumer le brumisateur pour humidifier et quand allumer les ventilateurs pour sécher l'air).
Peut-être aussi que centrer le delta d'allumage autour de la valeur demandé serais plus judicieux pour avoir une meilleur précision. Par ça j’entends, au lieu d'allumer les ventilateurs lorsque la température souhaité est atteinte et les éteindre trois degré en dessous, les allumer un degré au dessus de la valeurs souhaité et les éteindre un degré en dessous de la valeur souhaité

Lors de mes essais pour régler le problème d'affichage qui survenait lorsque les relais s'allumait (Le premier chiffre de la valeur de température lut par le capteur était remplacé par un caractère étrange), je pensai d'abords qu'ils en étaient la cause, mais après quelques essais, les boucles "while", pour une raison que j'ignore, semblent être en cause, en effet le problème survient même si les relais sont déconnectés. Cependant peut-être qu'avec la nouvelle version du code il n'est plus présent.
Miro VON DER BORCH (25/11/23) :
J'ai revus un peu la PCB ce matin afin d'ajouter deux potentiomètres en plus sur le circuit actuel, ces potentiomètres devrais servir à controler l'humidité souhaité à terme. Je les ai donc branché au pins analogue suivant :
A2 -> Potentiomètre d'humidité
A3 -> Potentiomètre d'humidité fin
Voici les captures d'écran de ce que ça donne et j'ai joins le fichier KiCad :

Le schéma mis à jour

La PCB mis à jour
Paul SPIRCKEL (29/11/2023) :
Après avoir consulté les modifications faites par Miro, je me suis lancé dans l'écriture du programme. Je n'avais pas accès au nouveau circuit donc j'ai programmé à l'aveugle. Afin d'être sûr que toutes les conditions sont lues, j'ai préféré décrire 4 if (trop chaud, trop froid, trop humide, top sec)  avec des deltas (centrés sur la valeur voulue) adaptés à chaque situation (on préférera trop froid plutôt que trop chaud et trop humide plutôt que trop sec). Je propose également d'ajouter au circuit un switch à 3 pins pour choisir entre le refroidissement par ventilation ou par cooler. Je propose les deux codes ci-dessous :

Ventilation et cooler séparés
#include <Adafruit_Sensor.h>

#include <DHT.h>
#include <LiquidCrystal.h>
#include "Arduino.h"
#include <Wire.h>
#include "Adafruit_SHT31.h"
//#include <Adafruit_I2CDevice.h>

#define SHTpin 

#define Relai_1 3 // pin3 devient le pin du relai 1 (Ventilateur 1)
#define Relai_2 4 // pin4 devient le pin du relai 2 (Ventilateur 2)
#define Relai_3 5 // pin5 devient le pin du relai 3 (Résistance de chauffe)
#define Relai_4 6 // pin6 devient le pin du relai 4 (Cooler)
#define Relai_5 13 // pin13 devient le pin du relai 5 (Système d'humidification)

LiquidCrystal lcd(7, 8, 9, 10, 11, 12); // connexion des ports de l'écran LCD

int adcTempPin = A0; // attribution du pin analogique A0 comme entrée du signal du potentiomètre de température
int adcTempPinfine = A1; // attribution du pin analogique A1 comme entrée su signal du potentiomètre de réglage fin de température
int Temp_poten = 0; // Temp_poten est la variable modifiée par les potentiomètres liés à la température
int adcHumPin = A2; // attribution du pin analogique A2 comme entrée du signal du potentiomètre d'humidité
int adcHumPinfine = A3; // attribution du pin analogique A3 comme entrée su signal du potentiomètre de réglage fin d'humidité
int Hum_poten = 0; // Hum_poten est la variable modifiée par les potentiomètres liés à l'humidité

void setup() {

pinMode(Relai_1, OUTPUT); // règle le pin 3 en output
pinMode(Relai_2, OUTPUT); // règle le pin 4 en output
pinMode(Relai_3, OUTPUT); // règle le pin 5 en output
pinMode(Relai_4, OUTPUT); // règle le pin 6 en output
pinMode(Relai_5, OUTPUT); // règle le pin 13 en output

pinMode(adcTempPin, INPUT); // règle le pin A0 (analogique) comme entrée du signal du potentiomètre Temp
pinMode(adcTempPinfine, INPUT); // règle le pin A1 (analogique) comme entrée du signal du potentiomètre Tempfine
pinMode(adcHumPin, INPUT); // règle le pin A2 (analogique) comme entrée du signal du potentiomètre Hum
pinMode(adcHumPinfine, INPUT); // règle le pin A3 (analogique) comme entrée du signal du potentiomètre Humfine

Serial.begin(9600); // initialise la comm.

//Section consacrée à l'affichage vouée à évoluer en fonction du système d'affichage choisi

 lcd.begin(16, 2);

 lcd.setCursor(0, 0);

 lcd.println("Temp = ");

 lcd.setCursor(0, 1);

 lcd.println("Set = ");

}

void loop() {

delay(2000); //attend un peu entre chaque mesures

Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125)); // poten prend comme valeur celle envoyée par le potentiomètre, divisée par 10 pour avoir un interval de température entre 0 et 70°C à laquelle on ajoutte celle d'un deuxième potentiomètre divisé par 100 pour avoir plus de précision
Hum_poten = ((7+analogRead(adcHumPin)/40)+(analogRead(adcHumPinfine)/125)); // poten prend comme valeur celle envoyée par le potentiomètre, divisée par 10 pour avoir un interval de température entre 0 et 70°C à laquelle on ajoutte celle d'un deuxième potentiomètre divisé par 100 pour avoir plus de précision

serial.print(Temp_poten);

// ---- CONTROLE DE LA TEMPERATURE ----

// Température trop élevée (max 1°C ou dessus de la température souhaitée)

if (sht31.readTemperature() > (1+Temp_poten) ){ // Si la température est supérieure à 1°C au dessus de la température souhaitée

 while (sht31.readTemperature() >= (Temp_poten-1) { // Le système de refroidissement se met en marche tant que la température n'est pas redescendue en dessous de 1°C sous Temp_poten

 delay(2000); 
 Serial.println(sht31.readTemperature());
 Serial.println("Température trop élevée");
 Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(Relai_1, LOW); // Le Relai_1 se ferme (Ventilateur 1 en fonctionnement)
 digitalWrite(Relai_2, LOW); // Le Relai_2 se ferme (Ventilateur 2 en fonctionnement)

 }

}

else {

 delay(2000); 
 Serial.println(sht31.readTemperature());
 Serial.println("Conditions atteintes");
 Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(Relai_1, HIGH); // Le Relai_1 s'ouvre (Ventilateur 1 en arrêt)
 digitalWrite(Relai_2, HIGH); // Le Relai_2 s'ouvre (Ventilateur 2 en arrêt)

}

// La température est trop faible (Maximum 3°C en dessous de la température souhaitée, ne pas monter plus haut que la température souhaitée)

if (sht31.readTemperature() < (Temp_poten-3) ){ // Si la température est inférieure à 3°C en dessous de la température souhaitée

 while (sht31.readTemperature() < (Temp_poten) { // Le système de chauffage se met en marche tant que la température n'est pas remontée à Temp_poten

 delay(2000); 
 Serial.println(sht31.readTemperature());
 Serial.println("Température trop faible");
 Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(Relai_3, LOW); // Le Relai_3 se ferme (Chauffage en fonctionnement)

 }
}

else {

 delay(2000); 
 Serial.println(sht31.readTemperature());
 Serial.println("Conditions atteintes");
 Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(Relai_3, HIGH); // Le Relai_3 s'ouvre (Chauffage en arrêt) 
}

// Température trop élevée MALGRE LA VENTILATION (plutôt un cas d'été) (max 5°C ou dessus de la température souhaitée)

if (sht31.readTemperature() > (5+Temp_poten) ){ // Si la température est supérieure à 5°C au dessus de la température souhaitée

 while (sht31.readTemperature() >= (Temp_poten-1) { // Le système de refroidissement se met en marche tant que la température n'est pas redescendue en dessous de 1°C sous Temp_poten

 delay(2000); 
 Serial.println(sht31.readTemperature());
 Serial.println("Température trop élevée");
 Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(Relai_4, LOW); // Le Relai_4 se ferme (Cooler en fonctionnement)

 }

}

else {

 delay(2000); 
 Serial.println(sht31.readTemperature());
 Serial.println("Conditions atteintes");
 Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(Relai_4, HIGH); // Le Relai_4 s'ouvre (Cooler en arrêt)

}

// ---- CONTROLE DE L'HUMIDITE ----

// Humidité trop élevée

if (sht31.readHumidity() > (Hum_poten+10) ){ // Si l'humidité est 10% au dessus de celle souhaitée

 while (sht31.readHumidity() > (Hum_poten) { // Le système de ventilation se met en marche tant que l'humidité n'est pas redescuendue jusqu'à Hum_poten

 delay(2000); 
 Serial.println(sht31.readHumidity());
 Serial.println("Humidité trop élevée");
 Hum_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(Relai_1, LOW); // Le Relai_1 se ferme (Ventilateur 1 en fonctionnement)
 digitalWrite(Relai_2, LOW); // Le Relai_2 se ferme (Ventilateur 2 en fonctionnement)

 }
}

else {

 delay(2000); 
 Serial.println(sht31.readHumidity());
 Serial.println("Conditions atteintes");
 Hum_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(Relai_1, HIGH); // Le Relai_1 s'ouvre (Ventilateur 1 en arrêt)
 digitalWrite(Relai_2, HIGH); // Le Relai_2 s'ouvre (Ventilateur 2 en arrêt)

}

// Humidité trop faible

if (sht31.readHumidity() < (Hum_poten-5) ){ // Si l'humidité est 5% en dessous de celle souhaitée

 while (sht31.readHumidity() <= (Hum_poten) { // Le système d'humidification se met en marche tant que l'humidité n'est pas remontée à Hum_poten

 delay(2000); 
 Serial.println(sht31.readHumidity());
 Serial.println("Humidité trop faible");
 Hum_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(Relai_5, LOW); // Le Relai_5 se ferme (Système d'humidification en fonctionnement)

 }
}

else {

 delay(2000); 
 Serial.println(sht31.readHumidity());
 Serial.println("Conditions atteintes");
 Hum_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(Relai_5, HIGH); // Le Relai_5 s'ouvre (Système d'humidification à l'arrêt)

}

}

Ventilation ou cooler
#include <Adafruit_Sensor.h>

#include <DHT.h>
#include <LiquidCrystal.h>
#include "Arduino.h"
#include <Wire.h>
#include "Adafruit_SHT31.h"
//#include <Adafruit_I2CDevice.h>

#define SHTpin 

#define cooling 6 // pin6 devient le pin du qui commande soit la paire de ventilateurs soit le cooler en fonction de la position de l'interrupteur
#define Relai_1 3 // pin3 devient le pin du relai 1 (Ventilateur 1)
#define Relai_2 4 // pin4 devient le pin du relai 2 (Ventilateur 2)
#define Relai_3 5 // pin5 devient le pin du relai 3 (Résistance de chauffe)
#define Relai_5 13 // pin13 devient le pin du relai 5 (Système d'humidification)

LiquidCrystal lcd(7, 8, 9, 10, 11, 12); // connexion des ports de l'écran LCD

int adcTempPin = A0; // attribution du pin analogique A0 comme entrée du signal du potentiomètre de température
int adcTempPinfine = A1; // attribution du pin analogique A1 comme entrée su signal du potentiomètre de réglage fin de température
int Temp_poten = 0; // Temp_poten est la variable modifiée par les potentiomètres liés à la température
int adcHumPin = A2; // attribution du pin analogique A2 comme entrée du signal du potentiomètre d'humidité
int adcHumPinfine = A3; // attribution du pin analogique A3 comme entrée su signal du potentiomètre de réglage fin d'humidité
int Hum_poten = 0; // Hum_poten est la variable modifiée par les potentiomètres liés à l'humidité

void setup() {

pinMode(cooling, OUTPUT); // règle le pin 6 en output
pinMode(Relai_1, OUTPUT); // règle le pin 3 en output
pinMode(Relai_2, OUTPUT); // règle le pin 4 en output
pinMode(Relai_3, OUTPUT); // règle le pin 5 en output
pinMode(Relai_5, OUTPUT); // règle le pin 13 en output

pinMode(adcTempPin, INPUT); // règle le pin A0 (analogique) comme entrée du signal du potentiomètre Temp
pinMode(adcTempPinfine, INPUT); // règle le pin A1 (analogique) comme entrée du signal du potentiomètre Tempfine
pinMode(adcHumPin, INPUT); // règle le pin A2 (analogique) comme entrée du signal du potentiomètre Hum
pinMode(adcHumPinfine, INPUT); // règle le pin A3 (analogique) comme entrée du signal du potentiomètre Humfine

Serial.begin(9600); // initialise la comm.

//Section consacrée à l'affichage vouée à évoluer en fonction du système d'affichage choisi

 lcd.begin(16, 2);

 lcd.setCursor(0, 0);

 lcd.println("Temp = ");

 lcd.setCursor(0, 1);

 lcd.println("Set = ");

}

void loop() {

delay(2000); //attend un peu entre chaque mesures

Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125)); // poten prend comme valeur celle envoyée par le potentiomètre, divisée par 10 pour avoir un interval de température entre 0 et 70°C à laquelle on ajoutte celle d'un deuxième potentiomètre divisé par 100 pour avoir plus de précision
Hum_poten = ((7+analogRead(adcHumPin)/40)+(analogRead(adcHumPinfine)/125)); // poten prend comme valeur celle envoyée par le potentiomètre, divisée par 10 pour avoir un interval de température entre 0 et 70°C à laquelle on ajoutte celle d'un deuxième potentiomètre divisé par 100 pour avoir plus de précision

serial.print(Temp_poten);

// ---- CONTROLE DE LA TEMPERATURE ----

// Température trop élevée (max 1°C ou dessus de la température souhaitée)

if (sht31.readTemperature() > (1+Temp_poten) ){ // Si la température est supérieure à 1°C au dessus de la température souhaitée

 while (sht31.readTemperature() >= (Temp_poten-1) { // Le système de refroidissement se met en marche tant que la température n'est pas redescendue en dessous de 1°C sous Temp_poten

 delay(2000); 
 Serial.println(sht31.readTemperature());
 Serial.println("Température trop élevée");
 Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(cooling, LOW); // Le système de refroidissement sélectionné se met en marche

 }

}

else {

 delay(2000); 
 Serial.println(sht31.readTemperature());
 Serial.println("Conditions atteintes");
 Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(cooling, HIGH); // Le système de refroidissement sélectionné s'arrête

}

// La température est trop faible (Maximum 3°C en dessous de la température souhaitée, ne pas monter plus haut que la température souhaitée)

if (sht31.readTemperature() < (Temp_poten-3) ){ // Si la température est inférieure à 3°C en dessous de la température souhaitée

 while (sht31.readTemperature() < (Temp_poten) { // Le système de chauffage se met en marche tant que la température n'est pas remontée à Temp_poten

 delay(2000); 
 Serial.println(sht31.readTemperature());
 Serial.println("Température trop faible");
 Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(Relai_3, LOW); // Le Relai_3 se ferme (Chauffage en fonctionnement)

 }
}

else {

 delay(2000); 
 Serial.println(sht31.readTemperature());
 Serial.println("Conditions atteintes");
 Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(Relai_3, HIGH); // Le Relai_3 s'ouvre (Chauffage en arrêt) 
}

// ---- CONTROLE DE L'HUMIDITE ----

// Humidité trop élevée

if (sht31.readHumidity() > (Hum_poten+10) ){ // Si l'humidité est 10% au dessus de celle souhaitée

 while (sht31.readHumidity() > (Hum_poten) { // Le système de ventilation se met en marche tant que l'humidité n'est pas redescuendue jusqu'à Hum_poten

 delay(2000); 
 Serial.println(sht31.readHumidity());
 Serial.println("Humidité trop élevée");
 Hum_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(Relai_1, LOW); // Le Relai_1 se ferme (Ventilateur 1 en fonctionnement)
 digitalWrite(Relai_2, LOW); // Le Relai_2 se ferme (Ventilateur 2 en fonctionnement)

 }
}

else {

 delay(2000); 
 Serial.println(sht31.readHumidity());
 Serial.println("Conditions atteintes");
 Hum_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(Relai_1, HIGH); // Le Relai_1 s'ouvre (Ventilateur 1 en arrêt)
 digitalWrite(Relai_2, HIGH); // Le Relai_2 s'ouvre (Ventilateur 2 en arrêt)

}

// Humidité trop faible

if (sht31.readHumidity() < (Hum_poten-5) ){ // Si l'humidité est 5% en dessous de celle souhaitée

 while (sht31.readHumidity() <= (Hum_poten) { // Le système d'humidification se met en marche tant que l'humidité n'est pas remontée à Hum_poten

 delay(2000); 
 Serial.println(sht31.readHumidity());
 Serial.println("Humidité trop faible");
 Hum_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(Relai_5, LOW); // Le Relai_5 se ferme (Système d'humidification en fonctionnement)

 }
}

else {

 delay(2000); 
 Serial.println(sht31.readHumidity());
 Serial.println("Conditions atteintes");
 Hum_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(Relai_5, HIGH); // Le Relai_5 s'ouvre (Système d'humidification à l'arrêt)

}

}

Quelques modifications sont à apporter puisque je n'avais pas le matériel :

Redéfinir l'échelle des valeurs Temp_poten correspondant au nouveau potentiomètre
Créer l'échelle des valeurs (%) Hum_poten correspondant au nouveau potentiomètre
Ajouter toutes les lignes d'affichage sur écran
Essayer d'utiliser des elsif avec une seule condition else qui permet de désactiver tous les relais
Trouver un moyen de contourner la connexion I2C
Ajouter toutes les bibliothèques nécessaires si elles n'y sont pas déjà
Trouver un moyen de déconnecter tous les appareils chauffants si la température est trop élevée pendant trop longtemps
Ajouter le shield de carte SD et faire en sorte que le programme soit lu dessus

Paul SPIRCKEL (13/12/2023) :
Je n'avais toujours pas le matériel à ma disposition. Je me suis penché sur la possibilité de récupérer le signal I2C du capteur directement en analogique sur la carte Arduino. Ceci ne semble pas possible car une connexion I2C requiert une communication entre 2 composants, typiquement le capteur et le contrôleur Arduino. Il faudra donc probablement ajouter un shield ou autre extension comportant des connexions I2C. Il faudra faire attention à ce que certains pins utilisés pour d'autres fonctions ne gênent pas des connexions du shield, sinon il ne fonctionnera pas. Idem si on utilise le "Wireless SD Shield" pour ajouter de la mémoire. D'ailleurs je me suis renseigné et il semblerait que la carte SD ne puisse être utilisée que pour stocker des données et pas du code. Il doit être possible de faire cela mais avec d'autres composants que je ne connais pas. C'est donc toujours un aspect à développer si un Arduino simple est un peu trop juste (quelques solutions ici ?). Sinon peut-être serait-il intéressant d'utiliser deux cartes (une pour la température, une pour l'humidité) reliées au même capteur.
J'ai essayé d'écrire le programme avec des else if :

#include <Adafruit_Sensor.h>

#include <DHT.h>
#include <LiquidCrystal.h>
#include "Arduino.h"
#include <Wire.h>
#include "Adafruit_SHT31.h"
//#include <Adafruit_I2CDevice.h>

#define SHTpin 

#define Relai_1 3 // pin3 devient le pin du relai 1 (Ventilateur 1)
#define Relai_2 4 // pin4 devient le pin du relai 2 (Ventilateur 2)
#define Relai_3 5 // pin5 devient le pin du relai 3 (Résistance de chauffe)
#define Relai_4 6 // pin6 devient le pin du relai 4 (Cooler)
#define Relai_5 13 // pin13 devient le pin du relai 5 (Système d'humidification)

LiquidCrystal lcd(7, 8, 9, 10, 11, 12); // connexion des ports de l'écran LCD

int adcTempPin = A0; // attribution du pin analogique A0 comme entrée du signal du potentiomètre de température
int adcTempPinfine = A1; // attribution du pin analogique A1 comme entrée su signal du potentiomètre de réglage fin de température
int Temp_poten = 0; // Temp_poten est la variable modifiée par les potentiomètres liés à la température
int adcHumPin = A2; // attribution du pin analogique A2 comme entrée du signal du potentiomètre d'humidité
int adcHumPinfine = A3; // attribution du pin analogique A3 comme entrée su signal du potentiomètre de réglage fin d'humidité
int Hum_poten = 0; // Hum_poten est la variable modifiée par les potentiomètres liés à l'humidité

void setup() {

pinMode(Relai_1, OUTPUT); // règle le pin 3 en output
pinMode(Relai_2, OUTPUT); // règle le pin 4 en output
pinMode(Relai_3, OUTPUT); // règle le pin 5 en output
pinMode(Relai_4, OUTPUT); // règle le pin 6 en output
pinMode(Relai_5, OUTPUT); // règle le pin 13 en output

pinMode(adcTempPin, INPUT); // règle le pin A0 (analogique) comme entrée du signal du potentiomètre Temp
pinMode(adcTempPinfine, INPUT); // règle le pin A1 (analogique) comme entrée du signal du potentiomètre Tempfine
pinMode(adcHumPin, INPUT); // règle le pin A2 (analogique) comme entrée du signal du potentiomètre Hum
pinMode(adcHumPinfine, INPUT); // règle le pin A3 (analogique) comme entrée du signal du potentiomètre Humfine

Serial.begin(9600); // initialise la comm.

//Section consacrée à l'affichage vouée à évoluer en fonction du système d'affichage choisi

 lcd.begin(16, 2);

 lcd.setCursor(0, 0);

 lcd.println("Temp = ");

 lcd.setCursor(0, 1);

 lcd.println("Set = ");

}

void loop() {

delay(2000); //attend un peu entre chaque mesures

Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125)); // poten prend comme valeur celle envoyée par le potentiomètre, divisée par 10 pour avoir un interval de température entre 0 et 70°C à laquelle on ajoutte celle d'un deuxième potentiomètre divisé par 100 pour avoir plus de précision
Hum_poten = ((7+analogRead(adcHumPin)/40)+(analogRead(adcHumPinfine)/125)); // poten prend comme valeur celle envoyée par le potentiomètre, divisée par 10 pour avoir un interval de température entre 0 et 70°C à laquelle on ajoutte celle d'un deuxième potentiomètre divisé par 100 pour avoir plus de précision

serial.print(Temp_poten);

// ---- CONTROLE DE LA TEMPERATURE ----

// Température trop élevée (max 1°C ou dessus de la température souhaitée)

if ((sht31.readTemperature() > (1+Temp_poten)) and (sht31.readTemperature() < (5+Temp_poten))) { // Si la température est supérieure à 1°C au dessus de la température souhaité

 while (sht31.readTemperature() >= (Temp_poten-1) { // Le système de refroidissement se met en marche tant que la température n'est pas redescendue en dessous de 1°C sous Temp_poten

 delay(2000); 
 Serial.println(sht31.readTemperature());
 Serial.println("Température trop élevée");
 Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(Relai_1, LOW); // Le Relai_1 se ferme (Ventilateur 1 en fonctionnement)
 digitalWrite(Relai_2, LOW); // Le Relai_2 se ferme (Ventilateur 2 en fonctionnement)

 }

}

// La température est trop faible (Maximum 3°C en dessous de la température souhaitée, ne pas monter plus haut que la température souhaitée)

else if (sht31.readTemperature() < (Temp_poten-3) ){ // Si la température est inférieure à 3°C en dessous de la température souhaitée

 while (sht31.readTemperature() < (Temp_poten) { // Le système de chauffage se met en marche tant que la température n'est pas remontée à Temp_poten

 delay(2000); 
 Serial.println(sht31.readTemperature());
 Serial.println("Température trop faible");
 Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(Relai_3, LOW); // Le Relai_3 se ferme (Chauffage en fonctionnement)

 }
}

// Température trop élevée MALGRE LA VENTILATION (plutôt un cas d'été) (max 5°C ou dessus de la température souhaitée)

else if (sht31.readTemperature() > (5+Temp_poten) ){ // Si la température est supérieure à 5°C au dessus de la température souhaitée

 while (sht31.readTemperature() >= (Temp_poten-1) { // Le système de refroidissement se met en marche tant que la température n'est pas redescendue en dessous de 1°C sous Temp_poten

 delay(2000); 
 Serial.println(sht31.readTemperature());
 Serial.println("Température trop élevée");
 Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(Relai_4, LOW); // Le Relai_4 se ferme (Cooler en fonctionnement)

 }

}

// ---- CONTROLE DE L'HUMIDITE ----

// Humidité trop élevée

else if (sht31.readHumidity() > (Hum_poten+10) ){ // Si l'humidité est 10% au dessus de celle souhaitée

 while (sht31.readHumidity() > (Hum_poten) { // Le système de ventilation se met en marche tant que l'humidité n'est pas redescuendue jusqu'à Hum_poten

 delay(2000); 
 Serial.println(sht31.readHumidity());
 Serial.println("Humidité trop élevée");
 Hum_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(Relai_1, LOW); // Le Relai_1 se ferme (Ventilateur 1 en fonctionnement)
 digitalWrite(Relai_2, LOW); // Le Relai_2 se ferme (Ventilateur 2 en fonctionnement)

 }
}

// Humidité trop faible

else if (sht31.readHumidity() < (Hum_poten-5) ){ // Si l'humidité est 5% en dessous de celle souhaitée

 while (sht31.readHumidity() <= (Hum_poten) { // Le système d'humidification se met en marche tant que l'humidité n'est pas remontée à Hum_poten

 delay(2000); 
 Serial.println(sht31.readHumidity());
 Serial.println("Humidité trop faible");
 Hum_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(Relai_5, LOW); // Le Relai_5 se ferme (Système d'humidification en fonctionnement)

 }
}

// Si aucune des conditions précédentes n'est remplie, tout les relais sont ouverts.

else {

 delay(2000); 
 Serial.println(sht31.readTemperature());
 Serial.println(sht31.readHumidity());
 Serial.println("Conditions atteintes");
 Hum_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));
 Temp_poten = ((7+analogRead(adcTempPin)/40)+(analogRead(adcTempPinfine)/125));

 digitalWrite(Relai_1, HIGH); // Le Relai_1 s'ouvre (Ventilateur 1 à l'arrêt)
 digitalWrite(Relai_2, HIGH); // Le Relai_2 s'ouvre (Ventilateur 2 à l'arrêt)
 digitalWrite(Relai_3, HIGH); // Le Relai_3 s'ouvre (Résistance de chauffe à l'arrêt)
 digitalWrite(Relai_4, HIGH); // Le Relai_4 s'ouvre (Cooler à l'arrêt)
 digitalWrite(Relai_5, HIGH); // Le Relai_5 s'ouvre (Système d'humidification à l'arrêt)

}

}

Il reste donc à faire :

Redéfinir l'échelle des valeurs Temp_poten correspondant au nouveau potentiomètre
Créer l'échelle des valeurs (%) Hum_poten correspondant au nouveau potentiomètre
Ajouter toutes les lignes d'affichage sur écran
Corriger le programme (je n'ai pour le moment pas pu me rendre compte de potentielles erreurs)
Ajouter toutes les bibliothèques nécessaires si elles n'y sont pas déjà
Trouver un moyen de déconnecter tous les appareils chauffants si la température est trop élevée pendant trop longtemps (fusible ou relai en plus)
Tester d'empiler l'Arduino Uno + le shield I2C et changer certaines connections pour que rien n'interfère (voir ici les pins I2C sont ceux de la rangée du bas)
Utiliser une autre carte ou augmenter la mémoire de programmation si celle de la carte ne suffit pas
Essayer d'ajouter un switch à 3 pins pour choisir le mode de refroidissement

Paul SPIRCKEL (24/01/2024) :
Je n'avais pas le matériel donc je me suis penché sur l'organisation du boitier et de la PCB. L'idée est de rendre la PCB très compacte et certainement de désolidariser le LCD de la PCB. J'ai commencé à faire un dessin de découpe de boite (plexiglas de préférence) qui permet sur une face d'avoir le LCD avec les 4 potentiomètres, sur les tranches, il faudrait mettre des sortes de prises pour connecter les différents appareils que l'on souhaite utiliser (aussi bien pour le côté modulaire de l'appareil que pratique quand il va falloir l'installer). A l'arrière, j'ai prévu un emplacement pour l'alimentation de l'Arduino (à voir si on met un transfo dans le boitier ou pas, ce qui risque de l'alourdir et de le chauffer). On pourrait rajouter un crochet sur le dessus pour suspendre le boitier par exemple. Avoir les composants répartis sur différentes faces implique de les désolidariser de la PCB, mais donc de la rendre plus petite (à voir ce qui est le mieux puisque qu'on va devoir ajouter des fils à l'intérieur).

J'aimerais si possible avoir accès aux dimensions des différents composants pour pouvoir finir ce modèle :)
Paul SPIRCKEL (31/01/2024) :
J'ai continué le patron du boitier. J'ai également réorganisé la PCB (fichier en pièce jointe). L'idée est de placer le LCD en haut, les potentiomètres alignés sur le côté, l'Arduino plus ou moins au centre et les relais alignés en bas. De cette manière on aura le plus de composants directement soudés sur la PCB. Il suffira d'adapter le patron du boitier aux bonnes dimensions. Il faudra aussi intégrer une alimentation 230V pour les relais et une dérivation de courant pour l'Arduino. Je n'ai jamais utilisé KiCad avant donc mon schéma est seulement visuel mais pas du tout fonctionnel. Si quelqu'un se sent de le faire proprement, ce serait super (je vais essayer d'apprendre d'ici là).
Paul SPIRCKEL (07/02.2024) :
Cette séance je me suis intéressé à la façon dont on pourrait faire varier la tension des panneaux LED. On pourrait utiliser un variateur de tension externe, sauf si l'on veut que la luminosité soit réglée automatiquement (mais est-ce que ça fait du sens ?). J'ai découvert une technique appelée PWM qui permet de générer des signaux analogiques réglables à partir de signaux numériques. Pour autant j'ai l'impression que ça ne génère que des sinusoïdes et pas des tensions constantes, mais la piste reste à creuser. Je n'ai pas pu le tester par manque de temps mais aussi parce que je n'ai jamais travaillé sur un ESP32 et je n'ai pas réussi à corriger des erreurs certainement causées par des problèmes de bibliothèques et autres. J'ai testé le capteur de luminosité, il fonctionne bien.
La boîte du projet est restée en Biologie / Chimie
Projet Greenduino

On cherche une solution pour construire un terrarium autonome. (Auteurs: SAMETOGLU Alper et VIVIEN Maël)
Solution envisagée
Alimentation à induction puissante pour alimenter la carte esp32, les LEDs, les capteurs et éventuellement la Mini pompe.

Dans ce projet, les ESP32 et ESP8266 sont utilisés (fonctionne sur Wifi 2.5 GHz)
Les avantages d'utiliser un ESP32

On peut facilement mettre un site web sur la carte pour la piloter à distance et il doit exister plein de tuto pour mettre en place un arrosage automatique avec cette carte.
La carte possède un assez grand nombre d'entrée /sortie pour brancher différents capteurs.

Les désavantages d'utiliser un ESP32

La logique des broches de la carte est en 3.5V, on doit donc ajuster les niveaux de tension de certains capteurs.

Le fonctionnement du projet

On peut envisager d’ajouter une batterie pour pouvoir faire fonctionner le système temporairement sans qu’il soit “branché” mais cela semble assez inutile et risque de rajouter des sources de pannes plus importantes.

La carte hébergera un site web de type apache (probablement) à partir duquel on pourra faire varier l'hygrométrie, la température si on rajoute un chauffage (l’alimentation devrait le permettre, surtout dans la mesure ou en enceinte fermée un petit chauffage devrait suffire)

(il faudra aussi déterminer si un chauffage est utile au vue de la chaleur dégagée par les différents composants)

Il faut donc acheter le chargeur à induction, les connecteurs étanches et éventuellement la mini pompe. Il faut trouver une alimentation externe suffisamment puissante ou l’acheter à défaut.
Trouver un relais (le piquer au fablab si besoin) pour les leds.
Réfléchir au câblage global, déterminer la liste exacte des capteurs à intégrer et trouver une personne capable de coder un joli site web.
Dessiner un boîtier à imprimer en résine pour accueillir l’ensemble de l'électronique ou acheter un boîtier étanche.
Il existe déjà un code source et des explications pour un arrosage automatique connecté qu’on a trouvé en ligne : Lien.

Liens qui peuvent être utiles

Alimentation à induction puissante
Mini carte de contrôle avec faible consommation énergétique  
Mini pompe

Sovol 3D (Lavage de résin) "Upgrade"

Dans ce projet, on cherche à trouver une solution à la machine de lavage Sovol 3D qui s'arrête après quelques essais. Pour cela, on envisage à changer la méchanisme de bouton (qui est actuellement faite avec une bouton de commutation) et la remplacer avec une système de bouton poussoire.

Tension : 110V/220V 50/60HZ 
Tension de sortie : 24 V 
Courant du produit : 0,3 A 
Puissance maximale : 7,2 W

Il y a deux composants principaux de la machine qui semblent défectueux :

Le moteur, au centre, qui est activé via le "bouton" de démarrage fixé à droite de la machine.

Après de multiples essais, il semble que le mécanisme moteur fonctionne bien, même s'il se met parfois à tourner sans même appuyer sur le bouton de démarrage...

Soit, le deuxième composant est la carte fixée sous les "boutons" externes,

Cela semble être le composant qui cause réellement le problème, car il semble y avoir un mécanisme non naturel de boutons "sans contact" qui activent certaines fonctionnalités de la machine, à savoir les boutons de démarrage, de réinitialisation et de minuterie. Le système de bouton en général semble être composé d'un ressort qui détecte le mouvement (destiné à un doigt mais semble que tout fonctionne vraiment) pour activer ladite fonction.

Le projet peut alors s'articuler autour de la recherche d'un moyen de tester les relais entre les boutons et le moteur, et peut-être d'un moyen de remplacer les boutons de type ressort par de véritables boutons cliquables.
Après quelques tests, on a confirmé que la machine s’arrête après même pas une minute (poir un réglage de 5 min) …
On utilise un Arduino Nano 328 comme base de notre projet, et pour le codage on se base sur des recherches conduites sur Internet et les forums de Github.
Première ébauche (22.3.2023)
const int startBouton = 2; // un bouton sur la broche 2
const int resetBouton = 3; // un bouton sur la broche 3
const int timerBouton = 4; // un bouton sur la broche 4
const int moteurPin = 5; // un moteur sur la broche 5

void setup()
{
 // on met le bouton en entrée
 pinMode(startBouton, INPUT_PULLUP);
 pinMode(resetBouton, INPUT_PULLUP);
 pinMode(timerBouton, INPUT_PULLUP);
 pinMode(moteurPin, OUTPUT);
 
}

int start_etat;
int reset_etat;
int timer_etat;
int t = 1;

void loop()
{
 start_etat = digitalRead(startBouton);
 reset_etat = digitalRead(resetBouton); 
 timer_etat = digitalRead(timerBouton);

 if(start_etat == HIGH)
 actionAppuiStart(); // le bouton est appuyé

 if(reset_etat == HIGH)
 break; // peut-être pas la meilleure solution : ajouter une fonction interrupt qui peut se faire même pendant le delay
 
 if(timer_etat == HIGH)
 actionAppuiTimer(); // le bouton est appuyé
 
 delay(10);
}

void actionAppuiTimer(){

 if (t = 3)
 t = 1;
 else
 t += 1;

}

void actionAppuiStart(){

 if (t = 1)
 digitalWrite(moteurPin,HIGH); // le moteur tourne pendant 5 minutes
 delay(300000);
 digitalWrite(moteurPin,LOW);

 if (t = 2)
 digitalWrite(moteurPin,HIGH); // le moteur tourne pendant 10 minutes
 delay(600000);
 digitalWrite(moteurPin,LOW);
 
 else
 digitalWrite(moteurPin,HIGH); // le moteur tourne pendant 15 minutes
 delay(900000);
 digitalWrite(moteurPin,LOW);

}
RéflexionsCe code est relativement simple : on est allé chercher une algorithme de « comptage » sur Youtube. Nous nous sommes croisés avec un tutoriel d’Arduino qui permet de réaliser une programme qui effectue le comptage requise pour la partie « Timer » de la machine, car nous avons l’idée que c’est la fonction celui-ci qui pose problème pendant l’exécution de la session voulue (5,10,15 min).
Après avoir appris comment faire le code sur Arduino IDE, notre prochain étape était de trouver quels « ports » à utiliser sur la carte Arduino, car apparemment notre système requiert une module qui se connecte à la première sortie à droite de la carte. Dans le tutoriel, toutes les connections nécessaires sont introduites, et nous nous sommes débrouillés pour déterminer lesquels à utiliser dans notre cas. Dans le code, on a aussi traité le sujet de relier ce système de « Timer » avec les boutons poussoirs qu’on veut introduire a la machine. Comme précédemment évoqué, les boutons actuelles de la machine peuvent influencer le démarrage de la machine, car son approche d’un système « à distance » crée une problème de « mal connexion » quand on veut commencer la procédure. Pour ceci, on  a introduit une partie dans le code où, selon le bouton cliqué sur la machine, le « Timer » effectue des durées selon notre souhait.
Le code nécessite bien sûr des améliorations, il n’est pas du tout complet et il y a la possibilité qu’il soit moins complexe. Comme nous sommes toujours à L1, nos connaissances sont assez limitées, donc les autres réflexions sont à considérer.
Liens
https://youtu.be/hriSLWYOMyM
https://youtu.be/EGNBmjVzZBE
https://youtu.be/gd1DUXZ8H34

Interface Arduino éclairage



Informations

Abel Coiffard

coiffard.abel@gmail.com
L2 DC EEA+Philosophie

13-27 oct

Contexte
J'ai récupéré une dizaine de très grands tube lumineux à LED et j'aimerais leur donner une nouvelle vie. J'ai donc pour projet de les relier à un microcontrôleur qui constituera une interface me permettant de les commander facilement pour tout usage possible (soirée, domotique...)
Objectifs
Objectif premier : simplement relier les LED à un microcontrôleur (type Arduino), l'interface en restera au code que j'implémenterai. Il faut pour celà trouver des MOSFET, des câbles pour la commande à distance, une source d'alimentation puissante et choisir l'arduino.
Objectif second : coder sur le microcontrôleur une communication série en USB avec un ordinateur pour le commander à partir du logiciel Touchdesigner et automatiser les processus.
Objectif troisième : réaliser une interface physique sous la forme d'un boîtier de commande qui permettrai de sélectionner différents "programmes" et "effets" ainsi que quelques valeurs sur des potentiomètres. Ces informations serviront à déclencher des effets codés au préalable dans le microcontrôleur. Un petit écran sera rajouté pour donner un retour sur le programme/effet/valeur sélectionné. Si l'écran comprend également un lecteur de carte SD un objectif bonus sera de permettre de lire/écrire des programmes sur et depuis cette carte.

(work in progress)
Matériel

10 MOSFET IRFZ44
10*5 mètres de câble (double câble)
10 résistances (valeur à calculer)
10 résistances 220ohm
2 Arduino nano
10 borniers à vis 2 pôles
10 led témoins

Quelques câbles internes au système
10 alimentations 24v1A (ou 1 * 24v10A)
Quelques chutes de plaques à trous
Du contreplaqué et du PLA

Machines utilisées
Fer à souder
Multimètre/oscilloscope
Découpeuse laser/imprimante 3d ? Pour le boîtier

Construction
Le plan :

Contraintes techniques : j'ai besoin de 10 sorties PWM sur mon microcontrôleur. Pour des raisons de coût j'ai donc acheté deux Arduino micro (6PWM chacune)
Étape 1
----
Étape 2
----
Étape 3
----
Journal de bord
Avancée du projet à chaque étape, difficultés rencontrées, modifications et adaptations (facultatif pour les petits projets)
13/10/2023
Test de la commande d'un tube à Led (consommant 22W en 24v) à partir d'une faible tension continue de 5v grâce au IRFZ44. Les premiers test se déroulent bien mais j'ai peut être cramé mon mosfet car il génère un courant de 30mA entre sa base et sa source. C'est 10mA de plus que ce peut supporter l'arduino donc impossible d'ignorer ce problème. Mais ça me fait penser à un autre problème : le PWM simule un signal analogique en faisant varier le rapport cyclique d'un signal carré à haute fréquence. Or si le mosfet n'est pas censé conduire par sa grille, un courant alternatif peut quand même passer par phénomène de capacitance. Donc dans tous les cas une résistance de faible valeur entre la sortie de mon Arduino et la grille d'un mosfet est nécessaire.
19/10/2023
Phasellus in purus quis justo feugiat vestibulum quis eu lacus. 😎 Etiam maximus metus vel massa pharetra convallis. Curabitur vel nunc orci. Praesent dolor dui, laoreet non massa non, pellentesque vestibulum quam. Sed posuere, dui quis semper pulvinar, eros nibh commodo elit, nec auctor arcu est et purus.
20/10/2023
Maecenas interdum turpis sit amet rutrum elementum. Aenean eget accumsan ligula. Phasellus et scelerisque lectus. Cras vel venenatis nulla. Integer tristique non diam et molestie. Pellentesque condimentum enim arcu, in commodo nunc commodo vel. Integer vitae neque facilisis, mattis elit sit amet, gravida turpis. Maecenas lectus mauris, fringilla ut lectus eu, condimentum finibus tortor 🤩🤩🤩Nouvelle page

Un modèle de documentation minimal pour tous les types de projets. Toutes les catégories ci-dessous doivent être renseignées, même de façon succincte.IMPORTANT : Merci de sélectionner le / les tags adéquats dans le menu de droite, et de ne pas créer de nouveau tag.Les fichiers sources doivent idéalement être joints à cette page grâce à l'icône trombone du menu de droite.Des hésitations sur comment bien documenter et utiliser l'interface ? Consultez le tutoriel "Comment documenter"
Informations

Prénom et nom
Adresse mail
Cursus / Laboratoire / Association
Date de début - Date de fin estimée (ou réelle)

Contexte
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec et mauris non ipsum tincidunt euismod. Donec sed accumsan sem. Proin odio sem, vehicula a suscipit et, efficitur quis diam. Nam in enim a ex bibendum ultricies. Suspendisse in mauris sit amet felis cursus condimentum.

Objectifs
Nulla imperdiet mattis neque non vehicula. Aliquam aliquam ac lectus non euismod. Nulla facilisi. Fusce fermentum enim magna, vel consectetur sem malesuada eu. Integer ac iaculis magna, dictum posuere neque. Sed pretium dignissim arcu, vel maximus felis cursus in.

Ajouter au moins une image de votre projet
Matériel

1 planche de CP peuplier 3mm (dimensions 300*600mm)
scotch de peintre
colle à bois
cutter
papier de verre grain moyen (80-100)

Machines utilisées
Trotec Speedy 100
Construction
(Fichiers, photos, code, explications, paramètres d'usinage, photos, captures d'écran...)
Étape 1
----
Étape 2
----
Étape 3
----
Journal de bord
Avancée du projet à chaque étape, difficultés rencontrées, modifications et adaptations (facultatif pour les petits projets)
03/04/2022
Duis tincidunt mattis sollicitudin. Aenean posuere sapien a metus consectetur, ut blandit tellus finibus. Vivamus convallis tincidunt metus, ut fringilla eros gravida nec. Cras dignissim urna et vestibulum feugiat. Phasellus tempor, nunc quis lobortis volutpat, dolor arcu fermentum elit, in eleifend enim sem fringilla metus. 🚨 Donec quis libero vehicula, varius tortor quis, vehicula libero !!! Cras ultricies tempus ante gravida hendrerit.
11/04/2022
Phasellus in purus quis justo feugiat vestibulum quis eu lacus. 😎 Etiam maximus metus vel massa pharetra convallis. Curabitur vel nunc orci. Praesent dolor dui, laoreet non massa non, pellentesque vestibulum quam. Sed posuere, dui quis semper pulvinar, eros nibh commodo elit, nec auctor arcu est et purus.
18/04/2022
Maecenas interdum turpis sit amet rutrum elementum. Aenean eget accumsan ligula. Phasellus et scelerisque lectus. Cras vel venenatis nulla. Integer tristique non diam et molestie. Pellentesque condimentum enim arcu, in commodo nunc commodo vel. Integer vitae neque facilisis, mattis elit sit amet, gravida turpis. Maecenas lectus mauris, fringilla ut lectus eu, condimentum finibus tortor 🤩🤩🤩
Un modèle de documentation minimal pour tous les types de projets. Toutes les catégories ci-dessous doivent être renseignées, même de façon succincte.IMPORTANT : Merci de sélectionner le / les tags adéquats dans le menu de droite, et de ne pas créer de nouveau tag.Les fichiers sources doivent idéalement être joints à cette page grâce à l'icône trombone du menu de droite.Des hésitations sur comment bien documenter et utiliser l'interface ? Consultez le tutoriel "Comment documenter"
Informations

Prénom et nom
Adresse mail
Cursus / Laboratoire / Association
Date de début - Date de fin estimée (ou réelle)

Contexte
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec et mauris non ipsum tincidunt euismod. Donec sed accumsan sem. Proin odio sem, vehicula a suscipit et, efficitur quis diam. Nam in enim a ex bibendum ultricies. Suspendisse in mauris sit amet felis cursus condimentum.

Objectifs
Nulla imperdiet mattis neque non vehicula. Aliquam aliquam ac lectus non euismod. Nulla facilisi. Fusce fermentum enim magna, vel consectetur sem malesuada eu. Integer ac iaculis magna, dictum posuere neque. Sed pretium dignissim arcu, vel maximus felis cursus in.

Ajouter au moins une image de votre projet
Matériel

1 planche de CP peuplier 3mm (dimensions 300*600mm)
scotch de peintre
colle à bois
cutter
papier de verre grain moyen (80-100)

Machines utilisées
Trotec Speedy 100
Construction
(Fichiers, photos, code, explications, paramètres d'usinage, photos, captures d'écran...)
Étape 1
----
Étape 2
----
Étape 3
----
Journal de bord
Avancée du projet à chaque étape, difficultés rencontrées, modifications et adaptations (facultatif pour les petits projets)
03/04/2022
Duis tincidunt mattis sollicitudin. Aenean posuere sapien a metus consectetur, ut blandit tellus finibus. Vivamus convallis tincidunt metus, ut fringilla eros gravida nec. Cras dignissim urna et vestibulum feugiat. Phasellus tempor, nunc quis lobortis volutpat, dolor arcu fermentum elit, in eleifend enim sem fringilla metus. 🚨 Donec quis libero vehicula, varius tortor quis, vehicula libero !!! Cras ultricies tempus ante gravida hendrerit.
11/04/2022
Phasellus in purus quis justo feugiat vestibulum quis eu lacus. 😎 Etiam maximus metus vel massa pharetra convallis. Curabitur vel nunc orci. Praesent dolor dui, laoreet non massa non, pellentesque vestibulum quam. Sed posuere, dui quis semper pulvinar, eros nibh commodo elit, nec auctor arcu est et purus.
18/04/2022
Maecenas interdum turpis sit amet rutrum elementum. Aenean eget accumsan ligula. Phasellus et scelerisque lectus. Cras vel venenatis nulla. Integer tristique non diam et molestie. Pellentesque condimentum enim arcu, in commodo nunc commodo vel. Integer vitae neque facilisis, mattis elit sit amet, gravida turpis. Maecenas lectus mauris, fringilla ut lectus eu, condimentum finibus tortor 🤩🤩🤩Arduino - Alina Pintea & Mehdi Chaabi & Mathias Benezeth

Objectif du projet :
Construire un programme sur Arduino permettant d'allumer une LED rouge si la température est supérieure à 25°C et une LED bleue si la température est inférieure à 25°C.
Étapes réalisées :
Étape 1 : Rassemblement des composants pour le circuit

4 câbles
Capteur de température
2 LED (rouge et bleue)
2 résistances
Un câble reliant l'ordinateur au circuit
Une plaquette

Étape 2 : Montage du circuit avec démonstration
Le montage du circuit a été effectué conformément au schéma suivant :

Étape 3 : Programmation pour contrôler les LED en fonction de la température
Voici le code Arduino utilisé pour contrôler les LED en fonction de la température :

#define LEDBLEU 10 // définition de la led bleue
#define LEDROUGE 9 // définition de la led rouge
#define CapteurTemp A0 //définit le pin pour le capteur de la température

void setup(){

 pinMode(LEDROUGE, OUTPUT); //Configure le pin comme sortie pour la LED Rouge 

 pinMode(LEDBLEU, OUTPUT); //Configure le pin comme sortie pour la LED Bleu

 pinMode(CapteurTemp, INPUT); //Configure le pin comme sortie pour le capteur de température 
}

void loop(){

 int valeurCapteurTemp = analogRead(CapteurTemp);

 float tension = (valeurCapteurTemp/1023.0)*5.0; // Convertit la valeur analogique en tension (5V)

 float temperature = tension * 25.0; //Convertit la tension en température en degrés Celsius

 if (temperature < 25.0) {

   digitalWrite(LEDROUGE, LOW);

   digitalWrite(LEDBLEU, HIGH);

 } else {

   digitalWrite(LEDROUGE, HIGH);

   digitalWrite(LEDBLEU, LOW);

 }
}
Étape 4 : Présentation des résultats

La LED Rouge s'allume car la température est supérieur à 25°C

-------------------------------------------------------------------------------------------------------------
La LED Bleu s'allume car la température est inférieur à 25°C

Programmation d'un capteur sonore

Informations

Cyrine DHOUIB , Rouaa TLAYSS, Rayane MEKOUAR
cyrine.dhouib@etu.sorbonne-universite.fr, rouaa.tlayss@etu.sorbonne-universite.fr,  rayane.mekouar@etu.sorbonne-universite.fr

M2 Management de l'innovation
2023/2024

Contexte
Ce projet a pour but d'intégrer et de programmer un capteur à un système électronique branché à une carte Arduino. Pour ce projet, nous avons choisi de programmer un capteur sonore.

Objectif
L'objectif est de pouvoir allumer et éteindre une LED en claquant des mains grâce au capteur sonore.

Matériel

Carte Arduino Uno
Capteur Sonore
Arduino Shield
LED et résistance
BreadBoard
Fils

Principe physique
Le capteur sonore est composé d'une plaque de diaphragme. Lorsque des vibrations sonores sont produites des bruits forts, elles frappent la plaque du diaphragme, ce qui la fait vibrer. Lorsqu'elle vibre, elle modifie la capacité, ce qui entraîne une variation de la tension. La tension peut alors être lue à l'aide de la fonction analogRead().

Construction
Étape 1
Nous avons d'abord effectué les branchements nécessaires. Le capteur sonore est branché sur un port analogique est la LED est branché sur les pins A et GND de la carte Arduino.

Étape 2
Nous avons ensuite écris un programme dont le but est de lire les données du capteur et de commander la LED. Dans un premier temps, nous déclarons les Pins de la LED et du capteur de son.

int sound_sensor = A2; //assign to pin A2
#define LED 12
bool etat_LED=false; 

void setup() 
{
 Serial.begin(9600); //begin Serial Communication
 pinMode(LED, OUTPUT);
 digitalWrite(LED, LOW);
}
 
Notre fonction void loop() va ensuite lire les données du capteur en boucle. Les données du capteur sont des valeurs entre 0 et 1023 qui oscille en fonction du bruit ambiant. Nous avons donc fixé un seuil au delà duquel nous changeons la sortie de la LED.

void loop()
{
 int soundValue = 0; //create variable to store many different readings
 soundValue = analogRead(sound_sensor)
 
 Serial.println(soundValue); //print the value of sound sensor
 
 if (soundValue > 150) { 
 if (etat_LED){ 
 digitalWrite(LED, LOW);
 etat_LED = false;
 //Serial.println("Led off");
 }
 else{
 digitalWrite(LED,HIGH);
 etat_LED=true;
 // Serial.println("Led on");
 } 
 }
 delay(100); //a shorter delay between readings
}
Difficultés rencontrées

La première difficulté de cette tache a été de définir un seuil adéquat. Pour un seuil trop élevé, la LED ne s'allume pas, pour un seuil trop faible, la LED s'allume et s'éteint trop souvent.  Nous avons donc mesuré le bruit ambiant afin de déterminer une valeur seuil suffisamment élevée pour déclencher le changement d'état de la LED. Nous avons également confondu les sorties analogiques et numériques, ce qui empêchait la LED de s'allumer.

Résultats

Après avoir uploadé notre programme, notre LED s'allume lorsqu'on émet prêt du capteur un bruit suffisamment fort comme un claquement de main.

 
Améliorations
Nous pourrions intégrer à notre système un capteur de lumière ambiante pour ajouter une condition d'activation de la LED.

Programmation d'un capteur sonore

Informations

Cyrine DHOUIB , Rouaa TLAYSS, Rayane MEKOUAR
cyrine.dhouib@etu.sorbonne-universite.fr, rouaa.tlayss@etu.sorbonne-universite.fr,  rayane.mekouar@etu.sorbonne-universite.fr

M2 Management de l'innovation
2023/2024

Contexte
Ce projet a pour but d'intégrer et de programmer un capteur à un système électronique branché à une carte Arduino. Pour ce projet, nous avons choisi de programmer un capteur sonore.

Objectif
L'objectif est de pouvoir allumer et éteindre une LED en claquant des mains grâce au capteur sonore.

Matériel

Carte Arduino Uno
Capteur Sonore
Arduino Shield
LED et résistance
BreadBoard
Fils

Principe physique
Le capteur sonore est composé d'une plaque de diaphragme. Lorsque des vibrations sonores sont produites des bruits forts, elles frappent la plaque du diaphragme, ce qui la fait vibrer. Lorsqu'elle vibre, elle modifie la capacité, ce qui entraîne une variation de la tension. La tension peut alors être lue à l'aide de la fonction analogRead().

Construction
Étape 1
Nous avons d'abord effectué les branchements nécessaires. Le capteur sonore est branché sur un port analogique est la LED est branché sur les pins A et GND de la carte Arduino.

Étape 2
Nous avons ensuite écris un programme dont le but est de lire les données du capteur et de commander la LED. Dans un premier temps, nous déclarons les Pins de la LED et du capteur de son.

int sound_sensor = A2; //assign to pin A2
#define LED 12
bool etat_LED=false; 

void setup() 
{
 Serial.begin(9600); //begin Serial Communication
 pinMode(LED, OUTPUT);
 digitalWrite(LED, LOW);
}
 
Notre fonction void loop() va ensuite lire les données du capteur en boucle. Les données du capteur sont des valeurs entre 0 et 1023 qui oscille en fonction du bruit ambiant. Nous avons donc fixé un seuil au delà duquel nous changeons la sortie de la LED.

void loop()
{
 int soundValue = 0; //create variable to store many different readings
 soundValue = analogRead(sound_sensor)
 
 Serial.println(soundValue); //print the value of sound sensor
 
 if (soundValue > 150) { 
 if (etat_LED){ 
 digitalWrite(LED, LOW);
 etat_LED = false;
 //Serial.println("Led off");
 }
 else{
 digitalWrite(LED,HIGH);
 etat_LED=true;
 // Serial.println("Led on");
 } 
 }
 delay(100); //a shorter delay between readings
}
Difficultés rencontrées

La première difficulté de cette tache a été de définir un seuil adéquat. Pour un seuil trop élevé, la LED ne s'allume pas, pour un seuil trop faible, la LED s'allume et s'éteint trop souvent.  Nous avons donc mesuré le bruit ambiant afin de déterminer une valeur seuil suffisamment élevée pour déclencher le changement d'état de la LED. Nous avons également confondu les sorties analogiques et numériques, ce qui empêchait la LED de s'allumer.

Résultats

Après avoir uploadé notre programme, notre LED s'allume lorsqu'on émet prêt du capteur un bruit suffisamment fort comme un claquement de main.

 
Améliorations
Nous pourrions intégrer à notre système un capteur de lumière ambiante pour ajouter une condition d'activation de la LED.

Ajout d'une RAM 8Go sur un PC portable

NOM: Jacob-Piacentini | Dangremont Di Crescenzo
PRENOM: Amaury | Art
MAIL: Amaury_Francois.Jacob@etu.sorbonne-universite.fr Art.Dangremont_Di_Crescenzo@etu.sorbonne-universite.fr
Cursus: L2 EEA
Introduction
L'ajout de mémoire vive (RAM) supplémentaire à votre ordinateur portable peut améliorer ses performances en permettant l'exécution plus fluide de plusieurs applications simultanément. Cette documentation vous guidera à travers les étapes nécessaires pour installer 8 Go de RAM supplémentaires sur votre ordinateur portable.
Matériel nécessaire

Module de mémoire RAM DDR4 8 Go SO-DIMM (vérifiez la compatibilité avec votre ordinateur portable)
Tournevis (généralement un tournevis cruciforme)
Médiator

Étapes d'installation
Étape 1: Vérification de la compatibilité
Assurez-vous que le module de mémoire RAM que vous avez acheté est compatible avec votre ordinateur portable en vérifiant les spécifications du fabricant ou en consultant le manuel de l'utilisateur.

Étape 1 : Dévissage
Utilisez un tournevis de précision pour dévisser les vis à l'arrière du PC portable.
Étape 2 : Séparation de la coque
Utilisez des médiators pour séparer délicatement la coque du PC portable.

Étape 3 : Débranchement de la batterie
Débranchez la batterie du PC portable.

Étape 4 : Ajout de RAM
Repérez l'emplacement de la RAM sur la carte mère du PC portable. (Voir Photo 5)Insérez la nouvelle RAM dans l'emplacement prévu.

Vérification de la nouvelle RAM
Pour vérifier si la nouvelle RAM a été correctement reconnue, vous pouvez ouvrir le gestionnaire des tâches (Ctrl + Shift + Échap sous Windows) et accéder à l'onglet "Performance" pour afficher la quantité totale de RAM installée.
BARE METAL

Informations

Réalisé par SEIGNOLE Nathan
nathan.seignole@etu.sorbonne-universite.fr
Profil GitHub : Perigorac
En EISE4 à Polytech Sorbonne
Durée du projet : 01/12/2023 ~ 01/04/2024

Noé, ceci est censé être une surprise. Merci de ne pas lire la suite ! Pas de spoil !
Contexte
Noé est un guitariste de grand chemin et de grande taille, qui se balade souvent dans la fac avec son instrument électroacoustique. Ainsi, pour son anniversaire, j'ai décidé de lui fabriquer une pédale d'effets à l'ésthétique douteuse en me basant sur une de nos passions communes, le RTOS les barres de métal.
Objectifs
L'objectif ici est de réaliser une pédale d'effets pour guitare qui fait passer le son entrant dans un tuyau en métal avant de l'amplifier à la sortie.
Elle devra remplir tous les critères d'une vraie pédale :

Bonnes impédances d'entrée de sortie, pour pouvoir être insérée dans une chaîne d'effets, un pedalboard, ou branchée directement sur un ampli
Allumage-extinction par footswitch, avec un bypass total du signal si éteinte
Contrôle du gain
Faible bruit (excepté le bruit induit par la barre métallique)
Alimentation en 9V, de préférence sur batterie
Robustesse à la saturation sonore

Un objectif secondaire serait d'y ajouter un système qui jouerait certains sons (comme par exemple la fameuse chute d'une barre de fer sur le sol) sur l'appui d'un bouton, et qui l'ajouterait au signal sonore de la guitare.
Matériel

1 Adafruit Audio FX Sound Board - 2MB Flash
6 disques piézoélectriques (buzzers / transducteurs, voir le fichier ODS joint pour plus de détails)
1 Boîtier en aluminium nu type BC
1 Interrupteur rotatif 12 positions
2 potentiomètres Alpha : 100k et 1M
3 boutons : 2 pour potentiomètres et 1 pour switch rotatif
2 footswitch : latché 3PDT et temporaire 2PDT
1 interrupteur flick
2 connecteurs Jack 6.3mm
1 connecteur pour batterie 9V
1 connecteur DC 9V
1 LED rouge
1 support LED chromé

4 amplificateur bas bruit LM386
4 sockets pour circuit intégré 8 pins
1 régulateur de tension 5V 78L05

De plus, plusieurs résistances et capacités seront utilisés. Les tests seront grandement aidés par un Analog Discovery 2.
Machines utilisées
Pour l'instant, aucune. L'impression d'un PCB est prévue, ainsi que la peinture de la boîte en alu.
Construction
(Fichiers, photos, code, explications, paramètres d'usinage, photos, captures d'écran...)
Étape 1 - Considérations acoustiques
S'il faut faire passer le signal sonore de la guitare dans une barre de métal, la meilleure solution est probablement d'utiliser des disques piézoélectriques. Ils se fixent facilement à une surface et résonnent très bien dans la bande du son audible (20 Hz ~ 20 kHz). De plus, ils jouent le rôle de transducteurs, c'est-à-dire qu'ils peuvent s'utiliser comme émetteurs de son ou comme récepteurs. J'ai donc choisi plusieurs piézos de tailles et de fréquences de résonance différentes.
Pour que la majorité de l'onde acoustique se propage dans la barre de métal et non dans l'air, j'ai utilisé des supports pour tuyau : un jeu en PVC, et un jeu en métal entouré de caoutchouc isophonique. J'ai également eu accès à deux barres de métal : une pleine et une creuse.
J'ai donc décidé d'utiliser la fonction Network de l'Analog Discovery 2, qui permet de dresser la réponse en fréquence d'un système, pour déterminer la configuration barre - support - piézo la plus intéressante pour la pédale. Cela me permet d'observer l'effet du passage du son dans la barre comme si c'était un filtre. Voici quelques résultats :
Barre creuse, support métallique, entre le DP035 et le DP035F

Barre creuse, support PVC, entre le DP035F et le TVF

Barre creuse, support PVC, entre le TVF et le DP035F

On remarque déja que le système atténue grandement le signal sonore (-40 dB en moyenne), ce qui est compréhensible étant donné les pertes entre les disque et les support, les support et la barre métallique, et la perte dans l'air sous forme de son chez le disque et la barre (en effet, lors des tests, on entend faiblement le son entrant sortir de la barre). De plus, chacun des transducteurs et des matériaux ayant sa propre réponse fréquentielle, la réponse globale du système est chaotique, surtout vers les hautes fréquences.
Choisir une configuration ayant un bon gain en basses fréquences donnera un effet de type "Bass Boost" au son, un effet souvent souhaité en guitare électrique, mais au contrairement à un filtre ad hoc, les hautes fréquences ne seront pas "lissées" et risquent de se trouver déformées. Pour éviter de devoir filtrer le signal après coup, on choisira un système dont la réponse fréquentielle ne présente pas de grandes disparités d'atténuation. Cela m'oriente plutot sur les supports en PVC, même si ceux-ci présentent des difficultés : leur section est rectangulaire, contrairement aux supports métalliques qui sont cylindriques et donc plus facilement collables sur les disques.
L'intérêt principal de cet étape est d'estimer le gain nécéssaire en sortie de la barre de métal et de dresser une ébauche de l'effet créé par la BARE METAL. Cependant, l'acoustique étant un domaine complexe qui dépasse ce qui est observable à l'écran, je vais devoir tester les différentes configurations "à l'oreille" pour trouver la meilleure, avec un circuit sommaire, une fois que les composants audio commandés seront arrivés.
Étape 2 - Prototypage complet
----
Étape 3
----
Journal de bord
Avancée du projet à chaque étape, difficultés rencontrées, modifications et adaptations (facultatif pour les petits projets)
15/02/2024
Début du projet de manière sérieuse. Soudure des disques piézo, test approfondis de leurs caractéristiques acoustiques.Lanceur de balle de ping pong



Ce projet a pour objectif la réalisation d'un lanceur de balle de ping pong qui peut projeter des balles selon plusieurs positions.Décoration lumineuse : un petit lampadaire


Informations

Louise CHORFI, louise.ch@orange.fr, M2 BMC, du 13.03.23 au 15.03.23

Contexte et objectif
Je souhaite faire une petite décoration pour une boite qui serait un décor de rue avec un lampadaire qui s'allume avec un interrupteur. Mon idée initiale ressemble à ce schéma :

Matériel

Fil de fer
interrupteur
support de piles
2 piles AAA
led orange
fil électrique
gaines de fil thermo rétractables

Machines et outils utilisés

Fer à souder et pinces

Station d'air chaud
Pince à dénuder

Pages de wiki utilisées : soudure et bonnes pratiques de soudure

Construction
souder : Dénuder le bout d'un fil électrique avec la pince à dénuder. Placer les deux éléments sur les pinces (photo 1 plus bas) de sorte que le fil et la patte se touchent. Allumer le fer à souder. Chauffer les deux éléments avec le fer à souder. Appliquer l'étain. Si besoin, nettoyer le bout du fer à souder sur l'éponge humide ou dans la maille métallique (dorée).
 pince à dénuder.
J'ai soudé les différents éléments en série un par un : pour mon circuit je veux pouvoir déplacer les fils, donc j'ai aligné les pattes de mes composants. C'est moins solide. Si on veut faire un objet électronique plus gros il faut que les éléments soient "fixés mécaniquement (repli) avant de souder. Mais dans mon cas, ça m'a semblé plus judicieux.Avant de souder le deuxième bout d'un fil, j'ai passé des gaines thermo rétractables pour recouvrir les fils qui sont à nu. C'est d'autant plus important pour mon lampadaire puisqu'il est en fil de fer et toucher ferait surement un court-circuit. Les gaines sont resserrées grâce à la station à air chaud (un sèche cheveux d'électricien en somme).

       

                   

         1 : Pas une soudure pratique pour aligner les fils ; 2 : soudure alignée etre la patte et le fil; 3 : gaines de fil thermorétractables.

Je ne savais pas si j'avais besoin d'ajouter une résistance. J'ai commencé par en brancher une de 1k.Ohm mais la luminosité de la led était trop réduite, j'ai enlevé a résistance.

Résultat :
 

D'autres éléments du décors sont en cours de réalisation. J'ajouterai une photo une fois tout terminé (si je termine un jour).Détecteur d'enveloppe et démodulation

Le circuit est conçu pour détecter les crêtes d'un signal électrique d'entrée et les extraire de manière précise en utilisant un détecteur de crête. Ensuite, ces crêtes sont démodulées pour récupérer les données modulées qui sont transportées par le signal d'entrée.
Les différentes parties du circuit:

Filtre passe-bas :
Pour éliminer les composantes haute fréquence du signal et ne laisser passer que le signal modulé de basse fréquence.

Détecteur d'enveloppe:

Diode : pour détecter l'amplitude du signal.
Condensateur : Pour stocker la charge et lisser le signal détecté.
Résistance : Pour fournir une impédance de charge au condensateur.
Amplificateur Opérationnel (AOP) : Pour amplifier le signal détecté.

Comparateur simple:
Le comparateur produit une sortie logique en fonction de la relation entre le signal d'enveloppe et la tension de référence. Si le signal d'enveloppe dépasse la tension de référence, la sortie du comparateur est logique "1", sinon, elle est logique "0".

💥 Découpe / gravure laser



Jeu de société Tenoking

Informations

Pascal CHRISTOPHE 
pascal.christophe51@gmail.com
Licence
18/01/2023 - 13/06/2023

Contexte
Dans le cadre de l’activité de Game design. J’ai esquisser un jeu de plateau qui mélange Échec et Shogi. 
Objectifs
Mon objectif principal est de crée des pièces et un plateau pour pouvoir jouer.

Matériel

1 planche de bois CP bouleau(dimensions 330*330*5mm)
1 planche de bois CP bouleau(dimension 293*110*5mm)
Vernis

Machines utilisées
Trotec Speedy 360
Construction
Étape 1
Graver et découper les pièces. attention faite de le verso des pièce avant le recto en fessant attention de prendre les CP 5mm (nouveau). 
Étape 2
Puis sur la planche de 330*330 graver le plateau bien centrer.
Étape 3
Passez du vernis sur les planches de bois. 
Journal de bord
23/05/2023
Création des du wiki. Création des fichiers .svg pour les pièces et du plateau et modélisation 3d du plateau.

Test des fichier .svg sur la découpeuse laser Trotec Speedy 360.
24/05/2023
Modification des fichier .SVG. et de la méthode de construction.
26/05/2023
Test des fichier des pièces en .SVG Modification du chevalier pour qu'ils soit plus grand. Choix du bois pour le rendu final.
30/05/2023
Gravure sur du contre-plaquée du plateau.  Augmenter le niveau de gravures sur la plateau pour un rendu plus propre.
01/06/2023
Gravure du plateau, gravure et découpe des pièces (echec). 

06/06/2023
Découpage des pièces problème sur le ficher .svg la découpe n'est toujours pas complète.
08/06/2023
Résolution du problèmes sur le fait que les pièces ne se découpé pas. 
09/06/2023
Découpage des pièces dé publication des fichier pour découpée les pièces.

Fichier :
Pieds pour un télescope sur banc d'optique


Informations

par Sébastien Moulinet (sebastien.moulinet@sorbonne-universite.fr)
pour la Plateforme de physique du master MEEF
période du 10-14 février 2023

Contexte
Une des expériences proposées aux étudiants du master MEEF Physique-Chimie consiste à déterminer le grossissement d'un télescope. Ceci demande de placer le télescope dans le prolongement d'un banc d'optique. Or placer le télescope horizontalement, et à la bonne hauteur, se révèle fastidieux en utilisant la monture équatoriale d'origine.
Objectifs
Nous remplaçons la monture par quatre pieds permettant de poser le télescope directement sur la paillasse. Ce nouveau support réutilise les brides présentes sur la monture d'origine.

Matériel

2 planches de MDF (300 x 600)
vinyle adhésif (~ 80 x 200)

Machines utilisées
Trotec Speedy 100 & Plotter de découpe Graphtec Cutting Pro
Construction
La structure des pieds est obtenue à partir de pièces issues de planches de MDF pouvant s'emboiter grâce à des encoches.
Afin de compenser le jeu entre deux pièces (la largeur des encoches n'étant pas exactement pas l'épaisseur de la planche), des bandelettes de vinyles sont collées au niveau des encoches.
Dispositif en situation de TP
Les éléments montés sur le banc d'optique permettent de simuler un objet lointain pour le télescope. Le télescope, sur son nouveau support, chevauche le banc d'optique. Il est ainsi à l’horizontal et à la bonne hauteur, l'alignement avec le reste du montage en est facilité. Un appareil photo derrière l'oculaire permet l’acquisition des images qui permettrons de mesurer le grossissement du télescope.Boite support DMD

Informations

Killian Guerrero
killian.guerrero@lkb.upmc.fr
Thèse au LKB
17 mars - 17mars

Contexte
J'effectue ma thèse au LKB en optique. J'ai recu recemment un nouvel instrument optique DMD. Il s'agit d'une matrice de micro-miroirs utilisé pour faire des masques d'intensité dans un faisceau optique. Le DMD est arrivé sans structure. Il me faut donc construire un boite à la découpeuse laser pour tenir l'écran à la bonne hauteur et au bon angle.
Objectifs
Découper à la découpeuse laser puis assembler la boite que j'ai conçu au préalable sur inkscape.

Matériel

1 planche de plexiglas PMMA (300x600)

Machines utilisées
Découpeuse laser
Construction
-Découpe laser
-Assemblage à la main
Journal de bord
17 mars 2022: Découpe laser partiellement réussi. Il faut que je redécoupe la face ci-dessous avec ce nouveau fichier.
Mini porte clef libellule

Informations

Alexandre Vaudelle
alexandre.vaudelle@etu.sorbonne-universite.fr
Polytech Sorbonne - EISE4
24/02/2023

Contexte
Petite requête de ma mère, j'apprend à me servir d'InkScape au passage.
Objectifs
Réaliser (avec amour) un petit porte clef en forme de libellule ! 

Matériel

1 plaque de PMMA 3mm rouge que j'ai tapé dans les chûtes

Machines utilisées
Trotec Speedy 100
Construction

On réalise tant bien que mal un vectoriel en suivant le super guide disponible sur ce même wiki. Artistiquement j'ai le niveau d'une huître donc je me suis servi du modèle ci-dessous comme calque.

Journal de bord
23/02/2023
Début et fin du projet. J'ai mis environ deux heures, en maitrisant le logiciel ça doit pouvoir se faire en 30-45min. Petite déception, on voit mal la différence entre les ailes d'une même paire. J'ai mis un niveau de gris plus bas afin qu'il y en ait une mais je n'ai pas osé le rendre suffisament prononcé de peur que les ailes grises soient trop discrètes. On réussi néanmoins à discerner les pairs entre elles donc le résultat me semble satisfaisant.
Matériauthèque Speedy 360

Le fichier svg de découpe / gravure est joint à cette page (menu latéral), ainsi que la fiche de réglages matériaux au format docx.
Cette matériauthèque est une aide pour les usager·ères (principalement étudiant·es) du Fablab Sorbonne Université, à qui peu de matières sont mises à disposition et qui utilisent les réglages conseillés par le Fablab dans la grande majorité des cas. Elle est donc surtout utile à des fins pédagogiques, pour comprendre comment un fichier doit être mis en forme, et quels paramètres peuvent intervenir dans les préréglages.

Le support noir est découpé au cutter dans une plaque de polypropylène alvéolée 2mm noire (dimensions 200mm*280mm). Ça devrait aussi bien rendre sur du carton plume noir (qui peut pour le coup être découpé à la laser).
Les jetons de matières plastiques sont encerclées d’un anneau de MDF 3mm découpé à la laser : l’objet dans le fichier svg ci-joint doit être adapté selon le kerf que vous obtenez en découpant les jetons de PMMA / acrylique, afin que le jeton plastique soit bien ajusté dans le cercle en MDF.
Les jetons de matériaux sont collés avec du scotch double face sur le support noir. Pour les jetons transparents, le scotch est collé sur le pourtour en MDF pour des raisons esthétiques.
Le fichier de jeton n’est pas parfaitement régulier, n’hésitez pas à en faire une version plus propre !

Vous pouvez adresser vos questions ou suggestions à clara.devanz@sorbonne-universite.fr Platine d'adressage électrique

Informations

Christophe Tourain
christophe.tourain@sorbonne-Universite.fr
IDV/CHNO 15-20  UM80 Sorbonne Université
19 septembre 2023 - 19 septembre 2023

Contexte
Adresser électriquement un modulateur thermo-optique de lumière, composé de 68 actionneurs.
Objectifs
Réalisation de perçage d'une platine en PMMA d'épaisseur 5 mm et de dimension 250 x 150 mm pour accueillir 68 fiches bananes femelles.
Matériel

1 plaque de PMMA 5 mm

Machines utilisées
Trotec Speedy 360
Construction

Journal de bord
25/09/2023
câblée et fonctionnelle

Boite à Idees


Informations

Alexandre Guerre
alexandre.guerre@sorbonne-universite.fr
SUMMIT
09/2023

Contexte
Dans le cadre de l'unité de service SUMMIT, il a été proposé de mettre à disposition une boite à idées afin de permettre une amélioration continue de l'unité.
Objectifs
L'objectif est de réaliser une boite avec un affichage, qui se ferme avec un cadenas et qui a une empreinte au sol d'environ une feuille A4.

Matériel

1 planche de PMMA 3mm (dimensions 800*500mm)
le fichier de découpe :  boiteIdees.svg
colle plastique

Machines utilisées
Trotec Speedy 300
Construction

Assembler la boite sans le couvercle.
Ajouter une des baguettes au bout du couvercle ce qui empêchera le couvercle de passer au travers.
Optionnel: Découper en 2 la dernière baguette et coller la de chaque côté afin de créer un rail pour le couvercle.

Journal de bord
Avancée du projet à chaque étape, difficultés rencontrées, modifications et adaptations (facultatif pour les petits projets)
25/09/2023
fabrication et montage

Étiquettes avec QR Code


Informations

Jean Younan & Angela Fournel-Meria
Médiateur.ices FabLab

Contexte
Élaboration d'étiquettes à la découpeuse laser incitant les utilisateurs à documenter leurs projets sur le Wiki
Objectifs
Réaliser une signalisation claire et assez présente pour être remarquée par tous

Ajouter au moins une image de votre projet
Matériel
Machines utilisées

Construction
Trophée lumineux


Informations

Alexandre Guerre
alexandre.guerre@sorbonn-universite.fr
SUMMIT
13/10/23

Contexte
Dans le cadre de la cohésion de l'unité SUMMIT, un concours intitulé SUMMUT SCORE RUGBY a été mise en place et il a été décidé de remettre un trophée au meilleur pronostiqueur.

Objectifs
L'objectif est de réaliser un petit trophée qui se place sur une base lumineuse. Il a fallu faire un dessin joli d'environ 15cm de large pour aller sur la base.
Le fichier résultant est le suivant trophe_rugby.pdf.
Matériel

1 planche de PMMA de 5mm

Machines utilisées
Trotec Speedy 100
Construction
Assembler la plaque et la base. Et voilà  :)
Pochoir pour électrode

Un modèle de documentation minimal pour tous les types de projets. Toutes les catégories ci-dessous doivent être renseignées, même de façon succincte.IMPORTANT : Merci de sélectionner le / les tags adéquats dans le menu de droite, et de ne pas créer de nouveau tag.Les fichiers sources doivent idéalement être joints à cette page grâce à l'icône trombone du menu de droite.Des hésitations sur comment bien documenter et utiliser l'interface ? Consultez le tutoriel "Comment documenter"
Informations

Prénom et nom
Adresse mail
Cursus / Laboratoire / Association
Date de début - Date de fin estimée (ou réelle)

Contexte
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec et mauris non ipsum tincidunt euismod. Donec sed accumsan sem. Proin odio sem, vehicula a suscipit et, efficitur quis diam. Nam in enim a ex bibendum ultricies. Suspendisse in mauris sit amet felis cursus condimentum.

Objectifs
Nulla imperdiet mattis neque non vehicula. Aliquam aliquam ac lectus non euismod. Nulla facilisi. Fusce fermentum enim magna, vel consectetur sem malesuada eu. Integer ac iaculis magna, dictum posuere neque. Sed pretium dignissim arcu, vel maximus felis cursus in.

Ajouter au moins une image de votre projet
Matériel

1 planche de CP peuplier 3mm (dimensions 300*600mm)
scotch de peintre
colle à bois
cutter
papier de verre grain moyen (80-100)

Machines utilisées
Trotec Speedy 100
Construction
(Fichiers, photos, code, explications, paramètres d'usinage, photos, captures d'écran...)
Étape 1
----
Étape 2
----
Étape 3
----
Journal de bord
Avancée du projet à chaque étape, difficultés rencontrées, modifications et adaptations (facultatif pour les petits projets)
03/04/2022
Duis tincidunt mattis sollicitudin. Aenean posuere sapien a metus consectetur, ut blandit tellus finibus. Vivamus convallis tincidunt metus, ut fringilla eros gravida nec. Cras dignissim urna et vestibulum feugiat. Phasellus tempor, nunc quis lobortis volutpat, dolor arcu fermentum elit, in eleifend enim sem fringilla metus. 🚨 Donec quis libero vehicula, varius tortor quis, vehicula libero !!! Cras ultricies tempus ante gravida hendrerit.
11/04/2022
Phasellus in purus quis justo feugiat vestibulum quis eu lacus. 😎 Etiam maximus metus vel massa pharetra convallis. Curabitur vel nunc orci. Praesent dolor dui, laoreet non massa non, pellentesque vestibulum quam. Sed posuere, dui quis semper pulvinar, eros nibh commodo elit, nec auctor arcu est et purus.
18/04/2022
Maecenas interdum turpis sit amet rutrum elementum. Aenean eget accumsan ligula. Phasellus et scelerisque lectus. Cras vel venenatis nulla. Integer tristique non diam et molestie. Pellentesque condimentum enim arcu, in commodo nunc commodo vel. Integer vitae neque facilisis, mattis elit sit amet, gravida turpis. Maecenas lectus mauris, fringilla ut lectus eu, condimentum finibus tortor 🤩🤩🤩Décorations pour les fêtes de fin d'année

Un modèle de documentation minimal pour tous les types de projets. Toutes les catégories ci-dessous doivent être renseignées, même de façon succincte.IMPORTANT : Merci de sélectionner le / les tags adéquats dans le menu de droite, et de ne pas créer de nouveau tag.Les fichiers sources doivent idéalement être joints à cette page grâce à l'icône trombone du menu de droite.Des hésitations sur comment bien documenter et utiliser l'interface ? Consultez le tutoriel "Comment documenter"

Contexte
Les fêtes de fin d'année arrivent !! Il est temps de faire des décorations ecolos! Bonne chance! :)
Objectifs
Faire des boules de décoration

Ajouter au moins une image de votre projet
Matériel
Environ 100euros (prendre des bons peintures pour un meilleur rendu)

1 planche de CP peuplier 3mm (dimensions 300*600mm)
Peintures sur bois de toutes les couleurs
scotch de peintre
colle à bois
cutter
papier de verre grain moyen (80-100)

Machines utilisées
Trotec Speedy 100
Construction
(Fichiers, photos, code, explications, paramètres d'usinage, photos, captures d'écran...)
Étape 1
Télécharger Inskcape (gratuit).

Étape 2
Dessiner sur Inkskape et imprimer. Voici le tuto de prise en main:
Se déplacer sur le canevas
Il y a plusieurs façons de se déplacer sur le canevas (le faire défiler). Utilisez les raccourcis Ctrl+flèche pour vous déplacer avec le clavier (essayez donc dès maintenant de faire défiler ce document vers le bas). Vous pouvez aussi agripper et déplacer le canevas en enfonçant le bouton du milieu de la souris. Ou bien, vous pouvez utiliser les barres de défilement (Ctrl+B permet de les afficher/masquer). La molette de la souris permet les déplacements verticaux, et même horizontaux en combinaison avec la touche Maj.
Zoomer et dézoomer
Le moyen le plus simple est d'utiliser les touches − et + (ou =). Vous pouvez aussi zoomer avec Ctrl+clic milieu ou Ctrl+clic droit, dézoomer avec Maj+clic milieu ou Maj+clic droit, et faire tourner la molette de la souris tout en appuyant sur Ctrl. Vous pouvez aussi cliquer sur le champ de saisie du zoom « Z » (dans le coin en bas à droite de la fenêtre), y saisir une valeur précise en %, et la valider en appuyant sur la touche Entrée. Enfin, il reste l'outil de zoom (dans la barre d'outils à gauche) qui vous permet de définir une région sur laquelle zoomer à l'aide de la souris.
Inkscape garde aussi en mémoire un historique des niveaux de zoom pour la session de travail en cours. Appuyez sur la touche ` pour revenir au niveau de zoom précédent et utilisez Maj+` pour retourner au suivant.
Les outils d'Inkscape
La barre d'outils verticale à gauche affiche les outils de dessin et d'édition d'Inkscape. La barre de commandes affiche les boutons des commandes générales, comme « Enregistrer » ou « Imprimer » et – suivant votre définition d'écran – elle se trouve soit en haut de la fenêtre, juste en dessous des menus, soit à droite de la fenêtre. Juste au-dessus de canevas (l'espace de travail), la barre de contrôle des outils montre les contrôles spécifiques à chaque outil. La barre d'état en bas de la fenêtre affiche des indications et des messages qui peuvent vous aider dans votre travail.
De nombreuses opérations peuvent être effectuées avec des raccourcis clavier. Pour consulter tous les raccourcis disponibles, ouvrez le menu Aide⇒Référence des raccourcis clavier et souris.
Créer et gérer des documents
Pour créer un nouveau document vide, utilisez Fichier⇒Nouveau ou appuyez sur Ctrl+N. Pour créer un nouveau document à partir d'un des nombreux modèles d'Inkscape, utilisez Fichier⇒Nouveau à partir d'un modèle… ou appuyez sur Ctrl+Alt+N.
Pour ouvrir un document SVG existant, utilisez Fichier⇒Ouvrir (Ctrl+O). Pour enregistrer, utilisez Fichier⇒Enregistrer (Ctrl+S) ou Fichier⇒Enregistrer sous (Maj+Ctrl+S) pour enregistrer sous un nouveau nom (même si Inkscape active par défaut l'option d'enregistrement automatique, il est toujours conseillé d'enregistrer son travail régulièrement).
Inkscape utilise le format SVG (Scalable Vector Graphics) pour ses fichiers. Le format SVG est un standard ouvert largement utilisé par les logiciels de graphisme. Les fichiers SVG sont basés sur le format XML et peuvent être édités à l'aide de n'importe quel éditeur de texte ou XML (ou avec Inkscape, bien sûr). En plus du SVG, Inkscape peut importer et exporter des documents dans bien d'autres formats. Vous trouverez la liste des formats de fichiers pris en charge dans les boîtes de dialogue des menus Enregistrer et Importer.
Inkscape ouvre une nouvelle fenêtre pour chaque document. Naviguez entre elles avec votre gestionnaire de fenêtres (avec le raccourci Alt+Tab par exemple), ou utilisez le raccourci Ctrl+Tab, qui permet de circuler parmi les documents ouverts (en guise d'entraînement, créez dès maintenant un nouveau document pour tester la navigation entre ce didacticiel et le nouveau document). Note : Inkscape traite ces fenêtres comme des onglets dans un navigateur web, ce qui signifie que le raccourci Ctrl+Tab ne fonctionne qu'avec des documents s'exécutant dans la même instance. Si vous ouvrez plusieurs fichiers depuis un navigateur de fichiers ou exécutez plusieurs instances d'Inkscape, cela ne fonctionnera pas.
Créer des formes
Il est temps de passer aux formes ! Cliquez sur l'outil Rectangle dans la barre d'outils à gauche (ou appuyez sur R) et avec un cliquer-glisser, créez un rectangle, soit dans un nouveau document vide, soit dans celui-ci :

Fond et contour
La façon la plus simple de donner une couleur à un objet est probablement de sélectionner un objet, puis de cliquer sur un échantillon de couleur dans la palette en bas afin de le peindre (changer sa couleur de fond).
Vous pouvez également ouvrir la boîte de dialogue Palettes depuis le menu Affichage (ou appuyer sur Maj+Ctrl+W), choisir une palette à partir du petit triangle dans le coin inférieur droit, sélectionner un objet, et cliquer sur une couleur pour le peindre (donc changer sa couleur de fond).
La boîte de dialogue Fond et contour du menu Objet (ou accessible avec Maj+Ctrl+F) est plus puissante. Sélectionnez la forme ci-dessous et ouvrez la boîte de dialogue Fond et contour.

Vous constatez que la boîte de dialogue a trois onglets : Fond, Contour et Style du contour. L'onglet Fond permet d'éditer le fond (l'intérieur) du ou des objet(s) sélectionné(s) (on parle aussi de remplissage — « fill » en anglais —, mais nous avons choisi une traduction brève pour des contraintes techniques). L'utilisation des boutons juste sous l'onglet vous permet de choisir le type de fond : transparent (aucun fond, le bouton avec un X), aplat (couleur de fond uniforme), ou encore dégradé linéaire ou radial. Pour la forme ci-dessus, le bouton Aplat devrait être sélectionné.
Plus bas, vous pouvez voir la collection de sélecteurs de couleur chacun dans un onglet : RVB, CMJN, TSL et d'autres encore. Vous pouvez également utiliser la roue, dans laquelle vous pouvez tourner un triangle pour choisir une teinte sur la roue, puis une nuance dans le triangle. Tous les sélecteurs de couleur comportent une réglette identifiée par la lettre « A » pour définir l'alpha (opacité) de la couleur sélectionnée.
Quand vous sélectionnez un objet, la boîte de dialogue Fond et contour est mise à jour pour afficher ses fond et contour actuels (quand plusieurs objets sont sélectionnés, elle affiche la moyenne de leurs couleurs). Jouez avec les exemples ci-dessous ou créez les vôtres :

Journal de bord
Avancée du projet à chaque étape, difficultés rencontrées, modifications et adaptations (facultatif pour les petits projets)
03/04/2022
Duis tincidunt mattis sollicitudin. Aenean posuere sapien a metus consectetur, ut blandit tellus finibus. Vivamus convallis tincidunt metus, ut fringilla eros gravida nec. Cras dignissim urna et vestibulum feugiat. Phasellus tempor, nunc quis lobortis volutpat, dolor arcu fermentum elit, in eleifend enim sem fringilla metus. 🚨 Donec quis libero vehicula, varius tortor quis, vehicula libero !!! Cras ultricies tempus ante gravida hendrerit.
11/04/2022
Phasellus in purus quis justo feugiat vestibulum quis eu lacus. 😎 Etiam maximus metus vel massa pharetra convallis. Curabitur vel nunc orci. Praesent dolor dui, laoreet non massa non, pellentesque vestibulum quam. Sed posuere, dui quis semper pulvinar, eros nibh commodo elit, nec auctor arcu est et purus.
18/04/2022
Maecenas interdum turpis sit amet rutrum elementum. Aenean eget accumsan ligula. Phasellus et scelerisque lectus. Cras vel venenatis nulla. Integer tristique non diam et molestie. Pellentesque condimentum enim arcu, in commodo nunc commodo vel. Integer vitae neque facilisis, mattis elit sit amet, gravida turpis. Maecenas lectus mauris, fringilla ut lectus eu, condimentum finibus tortor 🤩🤩🤩
Un modèle de documentation minimal pour tous les types de projets. Toutes les catégories ci-dessous doivent être renseignées, même de façon succincte.IMPORTANT : Merci de sélectionner le / les tags adéquats dans le menu de droite, et de ne pas créer de nouveau tag.Les fichiers sources doivent idéalement être joints à cette page grâce à l'icône trombone du menu de droite.Des hésitations sur comment bien documenter et utiliser l'interface ? Consultez le tutoriel "Comment documenter"
Informations

Prénom et nom
Adresse mail
Cursus / Laboratoire / Association
Date de début - Date de fin estimée (ou réelle)

Contexte
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec et mauris non ipsum tincidunt euismod. Donec sed accumsan sem. Proin odio sem, vehicula a suscipit et, efficitur quis diam. Nam in enim a ex bibendum ultricies. Suspendisse in mauris sit amet felis cursus condimentum.

Objectifs
Nulla imperdiet mattis neque non vehicula. Aliquam aliquam ac lectus non euismod. Nulla facilisi. Fusce fermentum enim magna, vel consectetur sem malesuada eu. Integer ac iaculis magna, dictum posuere neque. Sed pretium dignissim arcu, vel maximus felis cursus in.

Ajouter au moins une image de votre projet
Matériel

1 planche de CP peuplier 3mm (dimensions 300*600mm)
scotch de peintre
colle à bois
cutter
papier de verre grain moyen (80-100)

Machines utilisées
Trotec Speedy 100
Construction
(Fichiers, photos, code, explications, paramètres d'usinage, photos, captures d'écran...)
Étape 1
----
Étape 2
----
Étape 3
----
Journal de bord
Avancée du projet à chaque étape, difficultés rencontrées, modifications et adaptations (facultatif pour les petits projets)
03/04/2022
Duis tincidunt mattis sollicitudin. Aenean posuere sapien a metus consectetur, ut blandit tellus finibus. Vivamus convallis tincidunt metus, ut fringilla eros gravida nec. Cras dignissim urna et vestibulum feugiat. Phasellus tempor, nunc quis lobortis volutpat, dolor arcu fermentum elit, in eleifend enim sem fringilla metus. 🚨 Donec quis libero vehicula, varius tortor quis, vehicula libero !!! Cras ultricies tempus ante gravida hendrerit.
11/04/2022
Phasellus in purus quis justo feugiat vestibulum quis eu lacus. 😎 Etiam maximus metus vel massa pharetra convallis. Curabitur vel nunc orci. Praesent dolor dui, laoreet non massa non, pellentesque vestibulum quam. Sed posuere, dui quis semper pulvinar, eros nibh commodo elit, nec auctor arcu est et purus.
18/04/2022
Maecenas interdum turpis sit amet rutrum elementum. Aenean eget accumsan ligula. Phasellus et scelerisque lectus. Cras vel venenatis nulla. Integer tristique non diam et molestie. Pellentesque condimentum enim arcu, in commodo nunc commodo vel. Integer vitae neque facilisis, mattis elit sit amet, gravida turpis. Maecenas lectus mauris, fringilla ut lectus eu, condimentum finibus tortor 🤩🤩🤩Préparation UE IC 803

Séance de remise à niveau de découpe laser pour les CME.
Boite à tiroir.svg
HBox.svgSet de pions de Root


Informations

Louise CHORFI
louise.ch@orange.fr
Master 2 ITB
20 novembre 2023 - 21 décembre 2023

Contexte
Le but est de réaliser un set de pions personnalisés du jeu ROOT pour l'offrir a un ami qui aime beaucoup ce jeu.
Objectifs
Réaliser 10 pions en bois et peints avant le 21 décembre, remise des cadeaux de secret santa. Les pions font environ 1cm d'épaisseur, 1,5cm de largeur et 2cm de hauteur
  Croquis du concept                                                                           Pions finis !
Matériel

1 plaque de MDF naturel 6mm 30*60cm (chute, surface utilisée ~ 3cm* 60cm)
1 plaque de MDF naturel 3mm 30*60cm (chute, idem)
colle Cléopâtre blanche liquide
peinture gouache, acrylique blanche, posca doré, stylo noir
vernis à ongle transparent brillant

Machines et logiciel utilisés
Fablab : Trotec Speedy 360
Personnel : Inskcape (gratuit), Dremel (ponceuse)
Construction
Étape 1 : découpe laser
La découpeuse laser ne peut découper que 6mm d'épaisseur au maximum, pour m'approcher des 1cm d'épaisseur des pions originaux de ROOT, je vais découper la forme de mes pions sur une planche de 3mm et une planche de 6mm puis coller les deux pour obtenir 9mm d'épaisseur.
Sur inkscape : j'ai fait la forme des pièces à faire découper sur la découpeuse laser. En rouge les formes à découper, en noir les formes à graver. Fichier enregistré en .svg. Attention au zoom infini des fichiers vectoriels, il faut garder en tête la taille finale de la pièce, pour éviter d'avoir des détails trop petits.
Capture d'écran de mes chemins. Les pièces font 1cm de large, l'écart entre les gravures des oreilles et le bors de la pièce était en réalité trop petit bien qu'il me semblait clair sur l'ordinateur.
Sur l'ordinateur de la trotec 360, importer le fichier, bien mettre les mêmes dimensions pour avoir les pièces de taille la plus identique possible. J'ai découpé de quoi faire 24 pions, en prévoyant d'en rater quelques uns et de pouvoir faire des tests sur certains.Note : Les pions n'étaient finalement pas exactement de même taille, j'ai eu besoin de les poncer après le collage. Je ne sais si c'est dû à une mauvaise mise à l'échelle ou bien une variance d'épaisseur enlevée par la découpe laser entre la puissance utilisée pour découper en 3mm et en 6mm.Paramètres : >> Pour le MDF naturel 3mm : puissance 60% ; vitesse : 0,8% ; fréquence : 1000 ppi/hz>> Pour le MDF naturel 6mm : puissance 100% ; vitesse : 0,6% ; fréquence : 1000 ppi/hz>> gravure pour les deux : puissance 42% ; vitesse : 50 % ; fréquence : 500dpi
 Photo des pièces de 3mm découpées à la trotec 360
Étape 2 :  collage, ponçage

Coller les pions de 3mm et 6mm d'épaisseur ensemble.  Les collages donnent tous des dépassements à poncer pour que les bords soient bien lisses et la jointure ne soit pas remarquable. Ponçage avec la Dremel en utilisant une tête de "disque à poncer", 15 tour/sec. NB : Des lunettes (même rudimentaires) sont bienvenues pour éviter d'avoir de la poussière de bois dans les yeux.Tests :  colle blanche ou néoprène, la colle blanche suffit ; différents assemblages 3mm+6mm ou 3+3+3mm : équivalents, autant faire plus de pions en 3+6mm ; différentes têtes de la dremel pour poncer, je préfère le disque
[img poncage]  différence de taille à poncer                             matériel et pions poncés
Étape 3 : pyrogravure, peinture
Peinture des pions à la gouache. Première couche de vert uni (couleur des pions de la famille), séchage, puis peinture des détails, séchage et finitions avec un stylo fin noir.  Tests : Pyrogravure sur le bois et par dessus la peinture gouache, les deux sont faisables mais le rendu ne me plaît pas. La gouache n'était probablement pas le meilleur choix de peinture, de la peinture acrylique aurait été mieux.      

 tests de peinture et pyrogravure                            premiers pions peints.
Étape 4 : vernis
La gouache est une peinture soluble dans l'eau même après avoir séché. Pour éviter que les pions ne s'abîment je les ai vernis avec du vernis à ongles transparent.

Tests : Vernis à bois teint en brun, fonce la peinture. Vernis à bois transparent déplace la peinture. Vernis pour cuirs mais à base d'eau, déplace la peinture.  Base de vernis à ongles (top coat) donne une texture "adhérente" désagréable. Vernis à ongle (presque) transparent donne le meilleur rendu, malgré un voile blanc aux endroits où la couche est un peu trop épaisse.
Projet fini ! Il me reste 16 pions à offrir.

Gravure d'un QR code

Coordonnées

MIDI Leeann
leeann.midi-drouillard@etu.sorbonne-universite.fr
M1 Chimie

Introduction

Fait le 28/11/2023
Cette gravure a été faite pour le Village du Futur Souhaitable dans le cadre de l’UE MU4CIOIP.

Matériaux/Machine

Plaque de PMMA verte
Trotec Speedy 360

Construction

Le QR code était originalement sous format jpg

L’image a été transformé en fichier .svg à l’aide du logiciel Inkscape

Résultat

Quand on fait la gravure on obtient ce résultat :

Il n'y a pas assez de contraste pour que le QR code puisse être scanné donc la plaque a été peinte à la bombe. On obtient donc :
Gravure d'un cadre

Informations

Alicia LUONG
alicialuongtau@gmail.com
Licence
04/12/2023 - 13/12/2023

Contexte

Pour Noël, rien de tel qu'un cadre personnalisé comme cadeau.

Objectif

Graver un cadre.
Matériel

Cadre en bois, dimension : 22x17

jeux enfant - tour d'attaque

Informations

Alexandre Guerre
alexandre.guerre@sorbonneuniversite.fr
SUMMIT
15/11/23 - 20-11-23

Contexte
Dans le cadre d'une discussion philosophique avec mon fils de 5 ans, nous avons échafaudé un plan afin de prendre d’assaut son château Playmobil. Afin de réaliser cette attaque, il nous est paru évident qu'il était nécessaire de construire une tour d'attaque.

Objectifs
Réalisation d'une tour d'attaque à l'échelle Playmobil.
Voici le dessin de mon fils .

Le dessin revu par mes soins.

Matériel

2 planches de MDF de 3mm (dimensions 500*800mm)
1 tige de bois de 8 mm x 1m
colle à bois

Machines utilisées
Trotec Speedy 360
Construction
Une modélisation en 3D de l'objet a été faite sous fusion 360.

Ensuite un passage à la découpe laser puis un montage rapide à la colle à bois afin de donner le résultat.
fichiers utilisés : ta_page1.svg ta_page2.svg
Il manque la grosse masse sur le côté, que l'on a construit avec un pot de yahourt, des disques de carton et le reste de la tige de bois.

Puzzle du tableau périodique des éléments

Informations

Mbarik KARIHILA
mbarik.karihila@etu.sorbonne-universite.fr
M1 Chimie / ACID-SU
08/12/23 - 15/01/24

Contexte
Je souhaite mettre à l'épreuve les connaissances des chimistes et non-chimistes sur le tableau périodique des éléments par le biais d'un puzzle. C'est une façon ludique et amusante d'apprendre ou de réviser son tableau de Mendeleiev. :)
Objectifs
Le but final est d'avoir les cases du tableau périodique découpées dans une planche en bois. Les joueurs et joueuses pourront placer directement les cases dans les trous adéquats. Chaque pièce correspond donc à une case du tableau, sur laquelle sera gravée le symbole et le nom d'un élément chimique.
Photo du puzzle fini 
Matériel

2 planches de CP peuplier 3mm (dimensions 300*600mm)
colle à bois

Machines utilisées
Trotec Speedy 360
Construction
Étape 1

Vectoriser le tableau sur Inkscape

Au début, j'ai voulu vectoriser directement une image du tableau périodique, mais il y en avait peu où le numéro atomique de chaque élément n'apparaissait pas. Ce serait beaucoup trop facile à la résolution du puzzle. Donc j'ai décidé de faire moi-même, chaque case et inscrire le symbole et le nom de chaque élément dans la case correspondante.

Je pars du principe que je vectorise le tableau à l'échelle sur le logiciel. Je décide donc de faire des cases rectangulaires de 3cm de largeur sur 4cm de hauteur, afin d'avoir la place d'inscrire le symbole et le nom de chaque élément.
Je fais attention à ce que les cases soient tracées en rouge car elles seront découpées et les écritures en noir qui seront donc gravées.

screen fichier inkscape
Étape 2

Découpe laser à la Trotech 360

Une fois mon fichier svg terminé, je peux commencer la découpe et la gravure. Je fais bien attention à ce que le logiciel reconnaît les tracés rouges pour la découpe et les tracés noirs pour la gravure.
La durée du travail ne dure pas plus de 10 minutes.

Étape 3

Coller les planches ensemble

La dernière étape consiste à coller la planche avec les trous de découpe sur une autre planche vierge, afin d'avoir un support pour le puzzle.

armoire miniature

Zoe Lambert. Armoire en CP 3mm Gravure pour des plaques en bois décoratives sur des portes !

L'objectif de ce tout petit projet est de faire des plaques en bois gravés du prénoms de mes neveux et nièces pour décorer leur porte.
Tout d'abord, il fallait commencé par un test.

Nous avons tout d'abord pris des chutes de bois et gravé une image trouvé sur internet (on a pris Batman...).

Maintenant, nous devons la vectoriser. C'est un procédé assez long et relou a expliquer mais comme le wiki est bien fait, vous pouvez trouvé le tuto sur : "1. Tutoriels" -> "Logiciel" -> "Inkscape"
et pour l'utilisation de la machine : "1. Tutoriels" -> "Machines" -> "Découpeuse laser Trotec Speedy 100"

On était content pour le premier essai.

Mais on avait fait pas mal de bétises :

nous n'avions pas renseigner le bon type de bois dans le logiciel -> ça a pris feu (une toute petite étincelle mais ça nous a fait un peu peur).

nous avions mis une ligne de découpe beaucoup trop épaisse -> cela a carbonisé les bord de notre plaque.

Ensuite, j'ai fait un essai avec le design "final" de la plaque de chambre de mon neveu :

                                                 

Mais ici on s'était trompé sur l'épaisseur du CP peuplier. On avait paramétré pour du 3mm, mais c'était pas 3mm... c'était du 6mm... donc un peu dur a découper.

Et finalement, après avoir paramétré tout comme il faut, on a acheté les plaques (CP peuplier 3mm). Nous avons cela comme rendu :

Décoration sapin de Noël

Informations
·

 Apolline DURIEU
·

 apolline.durieu@etu.sorbonne-universite.fr
·

 Polytech Sorbonne - PeiP2
·

 18/12/2023 - 22/12/2023

Contexte
Je cherche à créer un sapin de Noël qui puisse tenir dans mon logement étudiant.

Objectifs
Créer un sapin de Noël personnalisable d’un assemblage de 3 plaques. Il doit pouvoir être démonté facilement si voulu.

Pièce de Jeu de société

Informations

Pascal CHRISTOPHE 
pascal.christophe51@gmail.com
Licence
18/01/2024 - 31/01/2024

Contexte
Dans le cadre de l’activité de Game design je fabrique un jeu de société.

Objectifs
Mon objectif est de crée des pièces .
Matériel

1 planche de bois CP bouleau(dimensions 330*330*3mm)

Machines utilisées
Trotec Speedy 360
Construction
Étape 1
Découper les pièces.
Étape 2
Écrire les chiffre dessus
Coque IPhone XI adaptable au support gopro



Arthur LABE—BRUGGHEMAN
Arthur.bruggheman@etu.Sorbonne-université.fr

BUT DU PROJET : Faire une coque pour iPhone11 pour pouvoir remplacer une gopro obsolète par le téléphone dont la qualité vidéo est meilleur. Pour le ski 😎. La fixation gopro étant déjà installée sur le casque.

REALISATION : Modélisation 3D puis impression

MATÉRIEL NÉCESSAIRE : le fichier slt et du filament pour l’impression 3D.

Pot avec boxes.py

J'ai utilisé le générateur de boite boxes.py, comme conseillé dans un tutoriel du wiki, en donnant les dimensions voulues. J'ai ensuite vectorisé sur Inkscape et colorisé les trajets en rouge.

résultat :
Posters Ghibli

Informations

Inès BENIKHLEF
ines.benikhlef@etu.sorbonne-universite.fr
CMI Physique

23.03.24

Contexte
Je trouvais que les murs de mon appartement manquent un peu de décoration, alors j'ai décidé de réaliser une petite série de posters Ghibli.
Objectifs

Graver sur une des chutes de plaques bois des posters miniatures (environ 15cm de hauteur).

Matériel

logiciel Inkscape
3 chutes de planches (CP 3mm et P
découpeuse laser

Réalisation
J'importe les trois modèles sur le logiciel Inkscape, les vectorise et les exporte individuellement en document SVG. Il ne me reste plus qu'à les graver.

Token New Phyrexia -- All Will Be One


TOKEN OF NEW PHYREXIA CREATION
Informations

Milo Reiss Ramdani Medhurst
b.rmmedhurst@gmail.com
CMI Physique
21/04/2024

Contexte
Je suis fan du jeu de cartes Magic: The Gathering et en vu de mon UE SXPFL je vais créer un token 2d du symbole "Phyrexian" (type de créature dans l'univers de ce jeu de carte).
Matériel utilisé

1 planche de bois CP Bouleau (dimensions 330 × 330 × 3 mm)
Découpeuse laser
Logiciel de design 2d: Inkscape

Objectif : l’objectif peut être décomposé en plusieurs parties :

Créer un cercle noir et pas rempli

Insérer une droite verticale passant par le milieu du cercle.

Attacher “All Will Be One” au cercle

Création du cercle
Pour créer le cercle étape par étape :

Insérez cercle.

Sélectionner le cercle et appuyer sur “stroke styles” ou simplement faire Ctrl+Shift+F

Aller sur l’onglet “stroke paint” puis appuyer sur “flat colour” afin d’avoir un extérieur de cercle visible.

Aller sur l’onglet “stroke style” et mettre l’épaisseur à 2.124

Sélectionnez le cercle, puis enlevez le remplissage en appuyant sur le symbole de croix en bas à gauche

Création de la droite
Pour créer la droite étape par étape :

Insérez un rectangle de hauteur 140.

Mettez l’épaisseur du rectangle à 0.177

Pour placer la droite de façon à traverser le milieu du cercle, vous pouvez localiser les coordonnées du centre du cercle puis placer le milieu de la droite à ce point-là. Cependant, placer la droite à un endroit vraisemblable à la moitié du cercle marche aussi.

Texte attaché :
Pour créer le texte attaché au cercle :

Insérez un texte “All Will Be One” en sans-serif et de police 36.5732

Sélectionnez le cercle, appuyez sur “path” en haut à gauche et appuyez sur “object to path”

Sélectionnez le cercle, appuyez sur Shift et sélectionnez le texte.

Appuyez sur l’onglet “text” en haut à gauche, puis appuyez sur “put on path”

Ajustez le texte sur le cercle de façon à ce que la droite passe entre les mots “Be” et “Will”

Tada!
🗿 Modélisation / Impression 3D



Impression de Soft Jaws en PA-CF

Informations

Nicolas Hammje
me@nicolashammje.com
www.nicolashammje.com
L3 Mecanique Intensive
04/07/23 - 04/07/23

Contexte
Le machinage de pieces en metaux souples permet de modifier des pieces existantes, peu cheres, pour quelles correspondent parfaitement a nos besoins. Cependant, pour un usinage de precision, il est necessaire de bien maintenir la piece en place pour eviter tout mouvement. 
Objectifs
Dans ce projet, nous exploitons l'impression 3D FDM pour créer des Soft Jaws sur mesure, assurant un maintien parfait de la pièce. La maniere traditionnelle de fabriquer des Soft Jaws a toujours été de les usiner en acier/aluminium, ce qui:

Encourt des délais de quelques jours
Occupe une machine qui pourrait être utilisée pour réaliser de vrais travaux
Nécessite un opérateur qui surveille l'usinage.

L'impression 3D permet d'obtenir un résultat de complexité très grande, le tout en un délai de quelques heures, et tout le travail s'effectue sans intervention ou surveillance, libérant l'opérateur pour d'autres täches.

Les Soft Jaws tenant la pièce à usiner
Matériel

1 Bobine de PA-CF (compter environ 100-200g)
3 heures

Construction
Étape 1
Après avoir mesuré l'espace disponible dans la fixation de la machine, modéliser un bloc à ces dimensions dans un logiciel de CAO. 
Étape 2
Effectuer un boolén entre le bloc crée précedemment et la pièce à fixer. Penser à rajouter une petite marge pour permettre aux forces de maintenir la pièce.
Étape 3
Imprimer en PA-CF (ou autre matériau rigide). Imprimer en outer/inner/infill pour obtenir des dimensions précises. Ici, les pièces furent imprimées à 60% de remplissage gyroid.
Test sur la perceuse colonne

Tout fonctionne niquel, le trou est impeccable et la pièce ne glisse pas du tout. De plus, les soft jaws n'ont pas été abimées et  peuvent donc être réutilisées.Crabe orange

Nom du projet : Crabe Orange
Coordonnées: Navarro Sophie en L1 Cursus Master et Ingénierie Physique, sophie.navarro@etu.sorbonne-universite.fr
Pour un projet personnel (avril 2023), j'ai décidé d'imprimer en 3D avec du filament orange une figurine de crabe. Ce projet n'avait pas d'objectif particuliers si ce n'est que de me familiariser au mieux avec l'utilisation du Logiciel Freecad et avec les imprimantes 3D du FabLab. Voici une capture d'écran du crabe sur le logiciel Freecad :

voici le fichier sur Freecad : vector final.FCStd
Ce crabe a été réalisé à l'aide d'ellipsoïdes et de sphères imbriquées sur le logiciel dans la section Part, par la suite fusionnées.
La seule difficulté rencontrée lors de la modélisation a été au moment de la fusion des différentes parties, car les arrêtes des ellipses se recoupaient là où elles se croisaient :

J'ai donc juste fait tourner les sphères des yeux sur un axe sans les déformer ou les bouger, de sorte que seulement seulement les arrêtes bougent, le problème était réglé.

Je mettrai une photo du résultat une fois l'impression finie.

Sophie NAVARRO

CMI PHYSIQUE L1 - Avril 2023Triloculina Gibba



Impression de Triloculina Gibba pour exposition paléontologique en bibliothèque
Dérailleur Simplex Prestige



Nom du projet: Galet de dérailleur Simplex

Coordonnées Duval Louis, 12-13 205 Laboratoire Kastler-Brossel/ INSP louis.duval [at] lkb.upmc.fr
Introduction 13/07/2023
Matériaux / Outils / Machines Imprimante 3D
Remerciement: Je tenais à remercier Simon Lanis pour m'avoir totalement encadré durant ce projet, pour me former sur l'utilisation de l'imprimante 3D

J'ai acheté un vieux vélo Peugeot, sur le bon coin. Ce sont des vélos accessibles de bonne qualité qui permettent l'accès à un vélo de route sans se ruiner avec une mécanique simple.

Il s'agit d'un PR 10, d'après les décalcomanies, il s'agit d'une édition de 1978!

Illustration du dérailleur
En allant à Jussieu, un ressort s'est cassé ce qui a endommagé mes galets de dérailleurs.De nombreuses personnes en ligne ont rencontré le même problème, et proposaient de les remplacer grâce à une simple impression 3D.
J'ai trouvé en ligne des détails sur ce blog:
http://technologiecmr.blogspot.com/p/fabriquer-des-galets-de-derailleur-avec.html
Il donne les détails du galet du dérailleur étape par étape

j'ai également trouvé un site ou les gens partagent des fichiers 3D, j'ai trouvé un fichier ou le galet était déja dessiné:
https://cults3d.com/fr/mod%C3%A8le-3d/divers/simplex-derailleur-gear
Il est accessible gratuitement, distribuable de manière non commerciale.Le fichier est accessible en attachement à ce wiki
Je souhaiterai imprimer ce fichier pour le tester, et éventuellement l'améliorer à l'avenir.
Dans l'idéal je souhaiterai que le matériau soit durable dans le temps, car racheté une pièce en plastique datant des années 80 ne garantie en rien qu'il durera longtemps.

Dans l'idéal, à l'avenir, j'aimerai également pouvoir refaire les ressorts de torsions. Malheureusement, dans l'industrie, il est impossible de trouver facilement un ressort se rapprochant sans devoir le retravailler. Il sera surement l'objet d'un futur projet.

Journal de bord Je vais essayer de donner mon avis sur les différents matériaux utilisés

19/07/2023
Une impression résine standard grise a été lancée, pour 4 galets. Il y a besoin de 22ml de résine, soit environ 90cts de résine.
Le fichier slicé est trop gros pour être sur le wiki mais peut être donné à la demande. Les pièces ont été décalées de 30° et quelques cm pour pouvoir avoir une impression optimale. Il est disponible sur ce lien:https://dropsu.sorbonne-universite.fr/s/cR3TcpD2riimcZTJe ne sais pas combien de temps il sera actif...
Les paramètres utilisés ont été les suivants:

Il s'agit des paramètres mis par défaut pour la machine.

Au bout d'1h45 d'impression les pièces sont finies:

Reste l'étape du durcissement...
20/07/2020:
Les pièces ont été retirées, le tout a l'air bien solide. L'impression a l'air d'être un succès.
Les pièces ont été retirées à l'aide d'une spatule métallique, puis passées dans un bain d'isopropanol.
Elles ont été ensuite mise 1h dans le générateur d'UV. Résultat final demain!
21/07/2020:

Les pièces ont fini de sécher et son prêtes à être installées.
13/08/2020:

La pièce centrale du mécanisme ne rentre pas dans la pièce et la résine est bien dure, ce qui ne permet pas de faire rentrer la pièce grâce à l'élasticité du mécanisme. J'ai essayé de limer l'intérieur pour gagner le dixième de mm qui manquait mais ce fut un échec.
Les dents se sont également cassées parce que le galet n'a pas tournée.
Clairement, le problème de la résine est qu'il est trop dur et cassant pour cet usage. En l'occurence, il adhère trop à la pièce centrale qui l'empêche de tourner correctement. Je suis curieux de savoir ce que ca donnerait si l'on ajoute 1/10eme de mm au trou central. Je suis également curieux de savoir ce que ca donnerait sur une pièce en métal.

Poignée de porte de garage


Nom du projet : Poignée de porte de garage
Coordonnées :  Loïc Becerra, Sorbonne Université - Campus PMC - Laboratoire INSP
Date : 26 et 27 septembre 2023
Matériaux / Outils / Machines : Imprimante 3D résine (couleur blanche)
Remerciement : Un grand merci à Simon Lanis pour son aide et ses conseils

Suite aux aléas du temps qui passe, la poignée de ma porte de garage s'est cassée. J'ai alors décidé de me lancer dans ce petit projet perso et de fabriquer une nouvelle poignée via la technique de l'impression 3D résine.
Le fichier source a été réalisé à l'aide du logiciel SolidWorks. Le fichier est en pièce jointe et voici ci-dessous un visuel.

J'ai donc imprimer ce fichier à l'aide d'une des imprimantes 3D résine du FabLab de SU, l'ELEGOO Saturn.
Une impression résine standard blanche a été lancée. Il y a besoin d'environ 120ml de résine. Les paramètres utilisés pour l'imprimante sont les paramètres par défaut de la machine. L'impression a duré quasiment 6 heures.
L'impression s'est bien déroulée. Après les étapes classiques de nettoyage à l'isopropanol et un bon séchage UV, la pièce souhaitée est nickel !

Crémaillère de lanceur de toupie Beyblade

Figurine Warhammer imprimée 3D



Informations

Romain Baharian
romain.baharian@etu.sorbonne-universite.fr
MTX Polytech
09/10/2023 - fin estimée au 20/09/2023

Contexte
Je suis passionné et investi dans le hobby Warhammer 40k, qui consiste à monter et à peindre des figurines de taille assez petite, et qui présentent un grand nombre de détails. Cependant, en tant qu'étudiant, je suis fauché, donc imprimer moi-même mes propres figurines me fait faire une économie monumentale (2€ total d'impression pour une figurine contre 35€ seule)
Objectifs
J'imprime en plusieurs pièces The Emperor's Champion, QG et personnage mythique de la faction des Black Templars. Pour rester fidèle au niveau de peinture que j'ai, il faut que l'impression se fasse avec le plus de détails possibles.

Fichier d'impression et rendu 3D de la figurine. Je n'imprimerai pas la tête, un autre casque lui sera mis. J'enlèverai l'espèce de relique sur son sac dorsal, elle est d'un moche... Idem pour le symbole sur sa jambe au sol, étant un symbole Dark Angels et non Black Templar... Enfin, je lui rajouterai les longs sceaux de puretés propres au champion de l'empreur, deux dans son dos.

Matériel

PLA 1.75mm gris

Machines utilisées
Imprimantes Raise3D Pro2
Construction
4 fichiers STL récupérés sur internet et réparés manuellement pour ajuster des détails.

Étape 1
Imprimer les trois pièces (corps, lame, sac)
Étape 2
Assembler

Étape 3
Fini
Journal de bord
Avancée du projet à chaque étape, difficultés rencontrées, modifications et adaptations (facultatif pour les petits projets)
09/10/2023
Première impression : le corps (sans lame d'épée, sac à dos ni tête). Hauteur de couche réglée à 0.02mm, une seule coque. Dimensions : environ 40mmx35mmx40mm. Supports avec jupe de taille 1.5mm. 7g de matière utilisée et 18h d'impression.
10/10/2023
Seconde impression. la première impression s'est bien passée, mais les détails de l'avant de la figurine ont été ratés du fait des supports. J'ai donc relancé l'impression en diminuant la hauteur de couche (pour passer de 0.02 à 0.01mm), ai légèrement diminué la vitesse d'impression (pour tester et voir l'influence) et réorienté la figurine pour que l'avant de celle-ci soit tourné vers le haut, sans contact avec les supports (ceux-ci seront en contact majoritairement avec la cape et l'emplacement du sac à dos, la cape pouvant être enlevée si besoin pour en faire une avec du green stuff (une pate polymère)). Toujours 7g de matière et 33h d'impression ...
Parallèlement j'ai lancé l'impression de la lame de "L'épée Noires" avec les mêmes paramètres. 2h30 pour 1.5g, je crains cependant que les inscriptions sur l'épée ne soient pas réussies de par leur petitesse.
Présentation du filament Moldlay et essai.

Tentative réalisée par C. Simon
Le filament Moldlay est un filament pour la réalisation de pièce destinées à la coulée métallique dans un moule à cire perdue.
Les conditions d'impression fournies par les différents distributeurs sont :

Nominal diameter
1.75 mm

Printing temperature
170 - 185 °C

Heated bed
not necessary, max. 40 °C

Length
> 210 meter

Weight
approx. 750 g

Avec une température de décirage annoncée de 270°C.
Le filament est cassant : une impression par des machines à entraînement  par la tête d'extrusion (Raise3D, BambooLab, Ender, etc.) sont préférables aux machines à entraînement auprès de la bobine (Ultimaker)

Si la machine était précédemment chargée avec du PLA, au chargement du filament Moldlay il est indispensable de régler le ressort de compression au niveau du moteur d'entrainement (on entend le clic-clic caractéristique d'une tension inadaptée).
Après quelques essais, on fixe la température d'extrusion à 190°C. La température du plateau de 30°C permet une bonne adhésion sur le BuildTek des Raise3D.
Les tentatives d'impression avec le profil PLA haute qualité modifié uniquement sur les aspects de température permet de sortir facile une pièce fine. La qualité de la pièce est peu satisfaisante : le crénelage est important, et la pièce est très fragile. Il faudra probablement régler les paramètres de hauteur de couche et rétractation.
Avec les chutes, on procède à un essai de décirage : le four de la salle de réalisation des circuits PCB permet de monter jusqu'à 260°C seulement : on voit bien que la cire coule, mais l'écoulement reste très visqueux.

Essais de recuit de PLA

Le recuit de pièces imprimées par FDM permet en principe d'améliorer :

l'aspect de surface
la résistance mécanique des pièces, en particulier dans l'axe z, une meilleure résistance à la traction inter-couches.

$fn = 50;
/* eprouvette de traction minimaliste */
difference() {
 translate([0,0,25]) cube([10,10,50], center = true);
 translate([0,0,5]) rotate([0,90,0]) cylinder(h = 12, r = 2.5, center = true);
 translate([0,0,45]) rotate([0,90,0]) cylinder(h = 12, r = 2.5, center = true);
}
Le fichier de description de l'éprouvette : eprouvette.scad
Le fichier STL : eprouvette.stl
Le fichier de préparation de l'impression, à 15% de remplissage, PLA en qualité standard. 6 éprouvettes, 4 verticales, 2 couchées : eprouvette_6-standard.idea

Le Gcode :  eprouvette.data et eprouvette.gcode.zip
A peine l'impression lancée, je réalise que c'est complètement idiot comme forme : le point de rupture est en effet évident, et sera toujours la partie fine où la masse d'épreuve vient s'accrocher...
Il faut donc bien prévoir une éprouvette de forme normalisée, et ne pas se contenter d'un parallélépipède.
Nouvelle éprouvette : eprouvette_v2.scad
$fn = 50;
/* eprouvette de traction - version 2 */

L = 70;
module forme() {
 union() {
 offset(r = -2) offset(delta = 2){
 translate([0,0]) square([4,L], center = true);
 translate([0,L/2]) square([15,15], center = true);
 translate([0,-L/2]) square([15,15], center = true);
 }
 }
}

linear_extrude(4) difference() {
 forme();
 translate([0,L/2]) circle(d = 3);
 translate([0,-L/2]) circle(d = 3);
}

Terrarium à drosera



Nom du projet: Galet de dérailleur Simplex

Coordonnées Duval Louis, 12-13 205 Laboratoire Kastler-Brossel/ INSP louis.duval [at] lkb.upmc.fr
Introduction 13/11/2023
Matériaux / Outils / Machines Imprimante 3D
Remerciements: Steve Hubert

Une drosera capensis et l'un des drosera que j'ai mis dans un terrarium oeuf.

Je possède des drosera capensis que j'ai acheté il y a maintenant 1 an

. N'ayant pas d'accès à de l'eau osmosée, elles ont commencé à vite dépérir. J'ai tenté un premier sauvetage à l'aide d'une bouteille d'iced tea, que j'ai utilisé pour faire un terrarium. J'en ai également mis une dans un autre terrarium mais à cause d'une humidité trop forte tout est mort.
J'ai donc décidé d'acheter un terrarium qui permet d'avoir une bonne luminosité à l'intérieur.

Encore une fois l'humidité est trop élevée et les drosera ont commencé à dépérir doucement.Après discussion avec Steve Hubert, il m'a suggéré d'utiliser un ventilateur. Le flux d'air pouvant aider a la diminution de l'humidité au niveau de la plante. Il permettrait également à brasser l'air .
Après l'achat d'un starter pack pour raspberry pi pico (que je recommande chaudement, il est moins cher sur Aliexpress), je me suis mis en tête de réaliser un système led et de ventilation pour ce terrarium. J'en ai également profité pour mettre un capteur d'humidité et de température pour chez moi.

Le montage utilisant la plaquette led du kit et un ventilateur. Afin de contrôler la luminosité des leds, j'utilise l'ADC du raspberry pi pico avec un potentiomètre. Pour contrôler le courant dans le ventilateur (max 0.18A) j'utilise également un potentiomètre comme une simple résistance variable.  J'affiche la température et l'humidité dans mon appartement à l'aide de l'écran LCD et du DHT11.

Cette breadboard est assez pénible et encombrante. j'aimerai donc intégrer tout le circuit dans le bouchon de mon terrarium. Toutefois, j'aimerai ne pas creuser le liège du bouchon. Je vais donc essayer de dessiner un modèle pour pouvoir imprimer le bouchon en 3D. Le bouchon fait 3cm d'épaisseur, ses deux rayons sont 10,5cm et 9,5cm. Je prévoit d'intégrer un système de grille afin de pouvoir régler le flux d'ai qui rentre dans le terrarium. Je prévois également de couvrir le raspberry pico.

Le fichier STL est disponible ici.projet perso modelisation binome RW



Informations

walid et rayan
Adresse mail
L2 et L3 Maths Physiques
21/11/23

Contexte
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec et mauris non ipsum tincidunt euismod. Donec sed accumsan sem. Proin odio sem, vehicula a suscipit et, efficitur quis diam. Nam in enim a ex bibendum ultricies. Suspendisse in mauris sit amet felis cursus condimentum.

Objectifs
apprentissage de la modélisation via la création d'un petit projet simple

Ajouter au moins une image de votre projet
Matériel

FREECAD

impression 3D

Machines utilisées
??
modelisation
(Fichiers, photos, code, explications, paramètres d'usinage, photos, captures d'écran...)
Étape 1
modelisation test + visionnage tuto
Étape 2
----
Étape 3
----
Journal de bord
Avancée du projet à chaque étape, difficultés rencontrées, modifications et adaptations (facultatif pour les petits projets)
03/04/2022
Duis tincidunt mattis sollicitudin. Aenean posuere sapien a metus consectetur, ut blandit tellus finibus. Vivamus convallis tincidunt metus, ut fringilla eros gravida nec. Cras dignissim urna et vestibulum feugiat. Phasellus tempor, nunc quis lobortis volutpat, dolor arcu fermentum elit, in eleifend enim sem fringilla metus. 🚨 Donec quis libero vehicula, varius tortor quis, vehicula libero !!! Cras ultricies tempus ante gravida hendrerit.
11/04/2022
Phasellus in purus quis justo feugiat vestibulum quis eu lacus. 😎 Etiam maximus metus vel massa pharetra convallis. Curabitur vel nunc orci. Praesent dolor dui, laoreet non massa non, pellentesque vestibulum quam. Sed posuere, dui quis semper pulvinar, eros nibh commodo elit, nec auctor arcu est et purus.
18/04/2022
Maecenas interdum turpis sit amet rutrum elementum. Aenean eget accumsan ligula. Phasellus et scelerisque lectus. Cras vel venenatis nulla. Integer tristique non diam et molestie. Pellentesque condimentum enim arcu, in commodo nunc commodo vel. Integer vitae neque facilisis, mattis elit sit amet, gravida turpis. Maecenas lectus mauris, fringilla ut lectus eu, condimentum finibus tortor 🤩🤩🤩Equation de noeuds sur OpenScad

Description
Introduction
Auteure du tutoriel : Clara Devanz
Il y a quelques temps, un ami m'a offert un livre fascinant d'Henry Segerman intitulé Visualizing Mathematics with 3D Printing. J'ai découvert cet ouvrage en ligne grâce au riche site web qui l'accompagne, 3dprintmath.com. Certains modèles sont même disponibles à l'impression sur Thingiverse ! Le livre donne plus d'explications sur les figures et la théorie, de façon accessible aux débutant·es.
Pendant la Fabacademy, il était demandé aux apprenant·es de modéliser et imprimer des formes difficiles voire impossibles à réaliser autrement qu'avec la fabrication additive. J'ai repensé à certaines formes expliquées dans le livre de Segerman, et tout particulièrement aux noeuds toriques.

Puisqu'il s'agît de visualiser des concepts mathématiquement bien définis, le logiciel de modélisation le plus adéquat m'a semblé être OpenScad. Ce logiciel libre permet en effet de décrire des volumes à partir d'équations. Je n'avais pas d'expérience préalable sur ce logiciel, c'est pourquoi je vous invite à me signaler en commentaire de cette page si vous voyez de meilleures façons de procéder ou des imprécisions. De même, si des grosses erreurs en topologie se sont glissées ici, ce n'est pas du tout un champ que je connais bien.
Voici le résultat obtenu après modélisation et impression de quelques noeuds toriques :

Noeuds

En mathématiques, et plus particulièrement en géométrie et en topologie algébrique, un nœud est un plongement d'un cercle dans ℝ3, l'espace euclidien de dimension 3, considéré à des déformations continues près. Une différence essentielle entre les nœuds usuels et les nœuds mathématiques est que ces derniers sont fermés (sans extrémités permettant de les nouer ou de les dénouer) ; les propriétés physiques des nœuds réels, telles que la friction ou l'épaisseur des cordes, sont généralement également négligées. [Wikipedia]

Mais encore ? Eh bien voici une vidéo tout à fait pédagogique de Carlo H. Séquin :

Noeuds toriques

Un noeud est torique s’il peut se réaliser à la surface du tore de révolution. Autrement dit, ceux-ci sont obtenus en enroulant un fil autour d'un tore en tournant p fois autour de l'anneau et effectuant q tours complets, où p et q sont des entiers premiers entre eux .

Par exemple le noeud de trèfle illustré ci-dessus fait deux fois le tour du tore dans la direction des parallèles pendant qu’il fait trois fois le tour dans la direction des méridiens. C'est le noeud torique (2,3). [source image]
Modélisation dans OpenScad
Méthode de hulling et exemple du noeud roulant
Equation d'un noeud de trèfle
J'ai commencé par chercher à modéliser le nœud torique le plus simple, qui est aussi le nœud non trivial le plus simple. Il s'agit du nœud de trèfle, également désigné comme le noeud torique (2,3). J'ai trouvé ces équations pour la première fois sur la page anglophone du noeud de trèfle (trefoil knot) de Wikipedia :

Je me suis d'abord concentrée sur les premières équations paramétriques données, et j'ai remplacé la fonction f(t) dans mon exemple OpenSCAD précédent de 'rolling knot' par celles-ci. Cela a fonctionné ! Et voilà mon premier noeud de trèfle modélisé dans OpenSCAD.

Généralisation à tous les noeuds toriques
Nous voulons maintenant généraliser ce que nous venons d'expérimenter avec un nœud de trèfle à tous les nœuds toriques.
Voici les équations paramétriques d'un noeud torique (p,q) [source : Wikipedia en]

Nous pouvons étendre ces équations à d'autres tores, en considérant les tores suivants :

le tore est à symétrie azimutale par rapport à l'axe z
c est le rayon entre le centre du trou et le centre du tube du tore
a est le rayon du tube
nous considérons uniquement les tores en anneau (c>a)

En écrivant les équations cartésiennes d'un tel tore, on peut alors obtenir les équations énoncées dans le blog Wolfram Mathworld :

Equation d'un tore en utilisant les coordonnées cartésiennes : (c-sqrt(x^2+y^2))^2+z^2=a^2 

Les équations paramétriques sont donc :

x = (c+acosv)cosu 
y = (c+acosv)sinu 
z = asinv 
pour u,v dans [0,2pi]. 
Pour revenir à notre nœud torique, nous pouvons finalement obtenir une description paramétrique du nœud torique (p,q) sous la forme d'une fonction f(t), en fixant u = q*t et v=p*t, pour t dans [0,2pi]. Cela nous donne :
c=10;// rayon entre le centre du trou et le centre du tube
a=6; // rayon du tube (c>a pour un anneau torique)
p=2; // tore (p,q) dans la notation où (p<q)
q=3; // tore (p,q) dans la notation où (p<q)

function f(t) = 
[ (c+(a*cos(q*t)))*cos(p*t),
(c+ (a*cos(q*t)))*sin(p*t),
(a*(sin(q*t)))
];
Nous sommes prêts à utiliser cette description paramétrique avec les solutions de hulling de KitWallace. Notez que comme OpenSCAD semble ne pas prendre en compte les radiants mais seulement les degrés, il faut itérer sur t allant de 0 à 359, et non de 0 à 2*pi.
Code OpenScad
Voici donc un code permettant de modéliser un noeud (p,q)  dans OpenSCAD :
// Clara Devanz - Fabacademy 2023
// Closely adapted code from the rolling knot code written by KitWallace (who also credits mathgrrl and nop head), but with knot torus parametric equations : https://mathworld.wolfram.com/Torus.html
// Here the notation where q > p is used. Thus q is the number of times the knot cross the center of the torus and p is the number ot times it turns around the z-axis.
// The torus is azimuthally symmetric about the z-axis; c is the radius from the center of the hole to the center of the torus tube, and a is the radius of the tube. We considered only ring tori (c>a).

// Here are the parameters you're invited to modify!

p=2; // (p,q) torus
q=3; // (p,q) torus
c=10; // radius from the center of the hole to the center of the tube
a=6; // radius of the tube
r = 2; // radius of the knot
step = 1; // steps of the 'for' loop calculating the knot's sections for t=[0: step: 359])
$fn=50; // number of fragments. Will change the 

function f(t) = 
[ (c+(a*cos(q*t)))*cos(p*t),
(c+ (a*cos(q*t)))*sin(p*t),
(a*(sin(q*t)))
];

module disc_p2p(p1, p2, r) {
 assign(p = p2 - p1)
 translate(p1 + p/2)
 rotate([0, 0, atan2(p[1], p[0])])
 rotate([0, atan2(sqrt(pow(p[0], 2)+pow(p[1], 2)),p[2]), 0])
 render() cylinder(h = 0.1, r1 = r, r2 = 0);
};

module tube(r, step) {
 for (t=[0: step: 359])
 assign (p0 = f(t), 
 p1 = f(t + step ),
 p2 = f(t + 2 * step))
 render() hull() {
 disc_p2p (p0,p1,r);
 disc_p2p (p1,p2,r); 
 }
};

scale(2) color([0.968,0.788,0.961]) tube (r, step);

Ce qui donne le résultat suivant :

J'aime beaucoup cette description paramétrique, la forme me semble plus réussie que le premier essai !
Vous pouvez voir dans le code qu'en plus des paramètres de la fonction paramétrique, nous pouvons également modifier certains paramètres de simulation. Voici donc la liste de tous les paramètres avec lesquels vous êtes invités à expérimenter :

p et q caractérisent le tore (p,q) sur lequel vous tracez votre nœud, dans la convention où p < q.
c est le rayon entre le centre du trou et le centre du "tube" du tore
a est le rayon du "tube" du tore (c>a pour un tore annulaire)
r est le rayon de la section du tube
step est la valeur des pas sur lesquels la boucle 'for' itère pour calculer les sections du nœud pour t=[0 : step : 359])
$fn est le nombre de fragments utilisés pour le calcul de la surface à travers la section du noeud

Illustrations de noeuds modélisés
Voici quelques nœuds toriques que j'ai rendus avec les paramètres suivants :

 

 

   

Impression des noeuds
Export en stl
Afin d'imprimer nos dessins en 3D, nous devons les exporter sous forme de fichiers .stl. Dans OpenSCAD, vous devez d'abord rendre votre modèle à l'aide de l'option render. C'est à ce moment-là que le logiciel effectue tous les calculs.
Ouvrez la console OpenSCAD pour vérifier quand il a terminé, car cela peut prendre de longues minutes ! Mes modèles ont mis entre 10 et 20 minutes à être générés (je n'ai pas mesuré le temps avec précision).
Quand c'est bon, vous devriez avoir un message similaire dans votre console :

Slicer
Comme d'habitude, j'ai utilisé le slicer ideamaker pour des impressions sur les Raise 3D Pro 2, en filament PLA d'une part, ABS d'autre part.

Résultats

noeuds en PLA
noeuds en ABS

Détailles pour un voiture radiocommandé

Pour les vacances, je voulais essayer un nouveau passe-temps, le drift RC, mais je ne voulais pas dépenser beaucoup d'argent. J'ai donc acheté une voiture vintage pour la moderniser et la convertir pour le drift. Certaines vieilles pièces gênaient les volants, donc j'ai les apporté quelques ajustements et les ai remodelées pour l'impression.

Les modeles sont fait en Onshape.
Image 1 : https://cad.onshape.com/documents/c4c84bf70190a1c9a797d10b/w/067d66c001e4ea2840b67224/e/6c015f3008fdc9620a829043?renderMode=0&uiState=6581a6e680bb366dab0ffdab
Image 2 : https://cad.onshape.com/documents/c1a281208462683420663e3e/w/c517e886817b2c40103e8694/e/a42f14ace8eb00115887baf0?renderMode=0&uiState=6581a5872173bc3525544c40
Image 3 : https://cad.onshape.com/documents/229eaa180f2b239b3ff13c09/w/6ad353d4030bba9d98d08655/e/b511bad250304dc6ea52747b?renderMode=0&uiState=6581a70cb047fd60169a1890
J'ai aussi imprimé une paire des roues de Cults3d: https://cults3d.com/en/3d-model/game/1-10-rc-rim-big-disc-energy

Buste de Paul McCartney

Informations

Date de réalisation : Décembre 2023
Auteur : Paul Rieunier 3810393 étudiant en M1 Physique Fondamentale et Appliquée

Contexte Perso
Mon père est fan de Paul McCartney (c'est une des deux raisons pour lesquelles je m'appelle Paul) et Noël approchait.Je me suis donc dis que c'était une bonne occasion pour mettre à l'œuvre mes compétences acquises en Modélisation et Impression 3D pour réaliser un cadeau de Noël sympa.
Matériel

Blender
Raise 3D Pro2 Plus
PLA Noir

Étape 1 : Trouver un modèle 3D de Paul McCartney
En une recherche google, c'était trouvé ! Pas très étonnant étant donné la popularité du célèbre chanteur.Un Modèle 3D officiel, spécialement créée pour être imprimé, avait été réalisé et publié en 2015 sur le site officiel (LIEN)

Étape 2 : Modification du modèle 3D
J'ai créé des coupures et un socle simplement avec Blender.Petit guide pour apprendre à rajouter du texte à un modèle 3D sur Blender : LIEN
Pour des arêtes de 0.2mm (soit la précision optimale de la Raise3D Pro2), le buste fait 11cm de haut.Il n'était donc pas nécessaire de réaliser l'impression en résine.

Étape 3 : Impression 3D
Le PLA Noir était bien la couleur de choix.Non seulement il permet de masquer les défauts et d'éventuelles taches, mais il permet aussi de créer des reflets qui viennent accentuer les reliefs.
Support de Grande Bobine

⚠️Hauteur prévue d'impression prévue : 9.9cm
Contexte
Les supports de bobine Raise sont trop courts et larges pour les grosses bobines bq.Il fallait créer des supports plus adaptés.
Support Raise trop court et trop large pour les grandes bobines bq
Modélisation 3D du support Raise modifié
Support Raise et Supports Imprimés
La version 1ère version (en Blanche) était plus proche de l'original et s'est cassée en tombant car la surface de section n'était pas suffisante.La nouvelle version (en Noir) est corrige ce défaut.
Ça marche bien ! 👍

Companion cube modulaire

Lien modèle 3D : https://www.thingiverse.com/thing:173570

L'ensemble des pièces à imprimer :

Moon Lamp

Lien modèle 3D : https://www.thingiverse.com/thing:4176380Molécule de Méthionine

Date de réalisation : 28 Janvier 2024
https://sketchfab.com/3d-models/methionine-25255b65825f462c8a7fdc191cbb9bb0

canon en maquette


Informations

Alexandre Guerre
alexandre.guerre@sorbonne-universite.fr
SUMMIT
28/02/2024

Contexte
Dans le cadre de la fabrication d'une maquette de bateau, il était nécessaire de fabriquer une master pour du moulage de canon.

Objectifs
L'objectif du projet était la modélisation et l'impression d'un master de canon à partir de plan 2D.

Matériel

Impression résine

Machines utilisées
Imprimante résine du FabLab
Construction
Modélisation dans Fusion 360, puis impression. Le fichier stl " canon.stl ".
Aucun montage nécessaire, juste un petit ponçage.
Magwell pour type CZ


Informations

Romain BAHARIAN
romainbaharian@gmail.com
MTX3
Début février 2024 - Fin mars 2024

Contexte
Je pratique du tir sportif ainsi que de l'airsoft. Les manipulations des armes de poing dans n'importe laquelle des disciplines est cruciale, pour garantir la sécurité et la performance. Ici, je recherche à créer un magwell, une pièce venant s'insérer en bas de la poignée pistolet et ouvrant d'avantage l'accès au rechargement, en évasant l'ouverture destinée au chargeur. On parle ici de chargeurs type Glock, dans une carcasse ressemblant aux P10 de la marque CZ.

Objectifs
Il me faut un magwell avec une pente d'insertion suffisamment faible pour avoir de l'effet, mais également obtue pour garantir une insertion rapide et efficace du chargeur. Le haut du magwell ne doit pas empiéter sur la prise en main de l'arme,  sinon très peu. Etant donné que j'utilise du PLA pour l'impression, la masse globale est trop faible pour être un problème.

Matériel

PLA noir 1.75mm
Papier à poncer

Machines utilisées
Raise 3D (imprimantes 3D)

Construction

Étape 1
J'ai réalisé jusqu'a présent trois versions du magwell. La première prenait en compte les dimensions d'entrée du chargeur, une petite planchette support pour le bas de la poignée, ainsi qu'une partie "chaussette" qui vient sur la poignée, pour tenir.
Cette version, dès le départ était vouée à n'être qu'un prototype. Comme prévu, elle n'a pas fonctionné. L'erreur est mienne : j'ai oublié de prendre en compte l'angle entre la poignée et le plateau d'insertion du chargeur, d'environ 70° (mesure plus qu'approximative)

Étape 2
Considérant l'échec cuisant de la V1, je suis reparti de 0 pour recréer un magwell sur une nouvelle esquisse, em m'inspirant d'avantage des magwells disponibles pour type 1911 - 20.11.

J'ai cette fois ci pris en compte l'angle poignée chargeur, et ai augmenté les angles d'intruduction du chargeur en dessous de la pièce. L'allure est plus carrée, malgré les chanfreins et congés appliqués à la pièce.

Étape 3
Après avoir chaussé le magwell sur l'arme, beaucoup de points sont venus se rajouter au cahier des charges :

Les angles sont trop prononcés, il faut arrondir d'avantage
Le chargeur ne se verrouille pas dans l'arme correctement : le magplate (talon de chargeur) est en contrainte avec les pentes d'insertion et empêche le bon locking du chargeur.

Le haut de la partie chaussette empiète trop sur la prise en main : soit raccourcir soit l'affiner.

Une fois toutes ces modifications faites, j'obtiens la V3 de mon magwell.

Cependant, je ne l'ai pas lancée en production, et ai préféré améliorer d'avantage le modèle, en diminuant l'angle d'insertion du chargeur ainsi qu'en élargissant cette partie. Je suis donc à la V4 (ou V3.5 selon les préférences)

Journal de bord
Dû aux problèmes indépendants de ma volonté sur les machines d'impression (bouchon dans l'extrudeur, warping excessif), je compte dans ce projet 4 modèles imprimés (V1, V2 x2 et V4) pour 6 échecs d'impression.

Paramètres d'impression :

Couche à 0.2mm
Jupe & radeau
Remplissage triangle à 35%

Conclusion

Le rapport résultat / effort est génial. Lorsqu'on aime designer en 3D, ce n'est en aucun cas une perte de temps. Le magwell est encore à tester dans les conditions appropriées (à mettre a jour)
impression figurine de personnage du jeu ROOT

Informations

Michel Fisun, michel.fisun.1@etu.sorbonne-universite.fr, L3 Mathématiques
Mamoune El Mellouki, mamoune.el_mellouki@etu.sorbonne-universite.fr, L3 Physique-Mathématiques
21/03/2024 - (en cours)

Contexte
Nous cherchons à offrir une figurine d'un personnage d'un jeu de plateau à un ami très fan de ce jeu

Objectifs
Reproduire et imprimer en 3D un personnage d'un jeu de plateau :

Matériel

(à voir, PLA blanc ? fil enrichi en bois ? )

Machines utilisées
(à voir, machine 3d PLA ou résine ?)
Construction

Modélisation sur Blender (en cours) :

Étape 1
Modélisation de la figurine sous Blender
Étape 2
Impression
Étape 3
Peinture de la figurine
Journal de bord
21/03/2024
Début de la sculpture du modèle 3D sur Blender Northrop YF-23

BRÉMOND Lison, L1 Cursus Master en Ingénierie, groupe A 2023-2024
lison.bremond@etu.sorbonne-universite.fr
Projet modélisation 3D YF-23

Impression en PLA avec supports - 4h - 48g
1. Fuselage
Le fuselage de la modélisation se compose d'une association de cylindres et de cônes de tailles diverses, de telle sorte à créer le corps principal d'une base de positionnement des éléments à venir :

//cylindre avant
translate ([39,0,1]) scale ([1,1,0.8]) rotate ([0,90,0]) cylinder (25,8,7.5,center=true);
//pointe centrale
translate ([-2.5,0,1]) scale ([1.5,1,0.8]) rotate ([0,90,0]) cylinder (39,0.1,8,center=true);
module pointeavant() { 
difference () { 
//long cylindre avant
translate ([83,0,-1]) scale ([1,1,0.8]) rotate ([0,100,0]) cylinder (25,7.73,3,center=true);
translate ([67,0,6]) scale ([2,5,5]) cube (5,center=true);
translate ([97,0,6]) scale ([1,5,5]) cube (5,center=true);
};
};
translate ([-20.5,0,0.2]) pointeavant();
//pointe tête
translate ([77,0,-2.3]) scale ([1,1,0.8]) rotate ([0,90,0]) cylinder (6,3.2,0.1,center=true);

2. Ailes et dérive
Pour concevoir les "grandes ailes" nommées ainsi dans le codage, la première tentative fut de venir créer des polyhedrons manuellement en plaçant chaque point selon la forme des ailes. Or, ces formes ne passant pas en format STL pour la suite de l'impression, l'alternative plus longue était de venir placer une différence d'un assemblage de cubes modifiés avec "scale" venant sculpter un autre cube plat de la forme d'une aile. On modifie l'épaisseur de cette même forme avec "scale" en z.
//grandes ailes
difference () { 
translate ([0,0,1]) scale ([30,25,0.5]) cube (4,center=true); 
translate ([52,30,0]) rotate ([0,0,35]) scale ([6,10,2]) cube (9,center=true);
translate ([52,-30,0]) rotate ([0,0,-35]) scale ([6,10,2]) cube (9,center=true);
 translate ([-52,30,0]) rotate ([0,0,-35]) scale ([6,10,2]) cube (9,center=true); 
 translate ([-52,-30,0]) rotate ([0,0,35]) scale ([6,10,2]) cube (9,center=true); 
 translate ([0,-70,10]) scale ([6,10,5]) cube (4,center=true); 
translate ([0,70,10]) scale ([6,10,5]) cube (4,center=true); 
};
On procède de la même manière pour la dérive, avec cette fois-ci une inclinaison de 35° selon l'axe y et l'ajout d'une plateforme arrière venant lier les deux ailettes.

//plateforme arrière
translate ([-40,0,1]) scale ([1,1,0.06]) cube (27,0.1,6,center=true);
//dérive
module derive() { 
 difference () {
 translate ([-43,25,0]) scale ([4,5,0.25]) cube (9,center=true);
 translate ([-8.5,35,0]) rotate ([0,0,27]) scale ([6,10,2]) cube (9,center=true);
 translate ([-74,35,0]) rotate ([0,0,-32]) scale ([4,7,2]) cube (9,center=true);
 translate ([-50,50,0]) scale ([4,2,2]) cube (9,center=true);
 translate ([-82,10,0]) rotate ([0,0,27]) scale ([6,7,2]) cube (9,center=true);
 translate ([-45,5,0]) scale ([7,2,2]) cube (9,center=true);
 }; 
3. Entrées d'air

Pour créer des entrées d'air, nous venons placer sous les "grandes ailes" deux parallélépipèdes rectangles aux bords arrondis avec la fonction "minkowski" symétriques et inclinés de 2° selon l'axe y (entrées 1 et 2 nommées dans le code), que l'on déplacent sous un module global avec "translate" et "rotate" de 5° selon x et 10° selon y (il faut veiller à changer le signe des angles de rotation et des coordonnées en y pour la symétrie).
--> Attention : L'inclinaison des entrée d'air vers le bas implique que leur partie haute traverse le niveau des ailes et dépasse ainsi sur le plan supérieur de l'avion. Il est donc nécessaire de venir faire une différence de ces parties parasites avec une forme suffisament grande (ici un cube de 8 unités de côté modifié avec "scale") qui ne sera plus visible après la manipulation.
Pour parvenir à creuser les entrées d'air, on procède de la même façon, avec cette fois une fonction "minkowski" comprenant des parallélépipèdes de dimensions 1.6 fois inférieures aux premiers. En créant une différence pour chacun des deux modules et en ajustant la hauteur de ces-derniers selon z, nous venons former nos creux.
//entrée d'air
module entree1() { 
 minkowski ()
 { 
translate ([0,-15,-3.2]) scale ([18,2.2,1.2]) rotate ([0,2,0]) cube (4,center=true);
cylinder (r=2,h=2,center=true); 
 };
 };
module entree2() { 
 minkowski ()
 { 
translate ([0,-15,-3.2]) scale ([18,2.2,1.2]) rotate ([0,2,0]) cube (2.5,center=true);
cylinder (r=2,h=2,center=true); 
 };
 };
difference () { 
translate ([-14,6,3]) rotate ([0,5,-10]) entree1(); 
translate ([2,3.2,1.7]) rotate ([0,5,-10]) entree2(); 
translate ([-17,0,6]) scale ([10,7,1.2]) cube (8,center=true);
};
 difference () { 
translate ([-19,23.5,3]) rotate ([0,5,10]) entree1(); 
translate ([-0,26.8,1.3]) rotate ([0,5,10]) entree2(); 
translate ([-17,0,6]) scale ([10,7,1.2]) cube (8,center=true);
};
4. Partie arrière
Pour toute la partie arrière, on vient ajouter deux sphères que l'on allonge de chaque côté de la pointe précédemment modélisée située au centre du plan supérieur de l'avion. Pour créer des faces plates, on modélise des cubes plats avec "scale" que l'on positionne et abaisse au niveau des deux sphères en créant une différence. Enfin, on modélise une nouvelle fois deux cubes aux extrémités des deux sphères, avec une fonction différence supplémentaire, de sorte à former des creux rectangulaires à l'arrière de l'appareil.

difference () { 
translate ([-28,8,1.5]) scale ([6,1.2,0.9]) rotate ([260,0,0]) sphere (6,center=true);
translate ([-28,8,7]) scale ([9,1.7,0.5]) cube (6,center=true);
translate ([-60,0,0]) scale ([2,4.5,2]) cube (6,center=true); 
translate ([-50,8,6]) rotate ([0,-10,0]) scale ([5,2.5,1]) cube (6,center=true);
//creux
translate ([-47,8,3]) scale ([3,0.8,0.5]) cube (8,center=true);
translate ([-35,0,-2]) scale ([4,4,0.5]) cube (10,center=true); 
translate ([-20,0,-5]) scale ([8,4,1]) cube (10,center=true);
 //retraits bordures arrières
 translate ([-43,16,2]) scale ([7,1,1]) cube (4,center=true);
}; 
difference () { 
translate ([-28,-8,1.5]) scale ([6,1.2,0.9]) rotate ([260,0,0]) sphere (6,center=true);
translate ([-28,-8,7]) scale ([9,1.7,0.5]) cube (6,center=true);
translate ([-60,0,0]) scale ([2,4.5,2]) cube (6,center=true); 
translate ([-50,-8,6]) rotate ([0,-10,0]) scale ([5,2.5,1]) cube (6,center=true);
//creux
translate ([-47,-8,3]) scale ([3,0.8,0.5]) cube (8,center=true);
translate ([-35,0,-2]) scale ([4,4,0.5]) cube (10,center=true); 
translate ([-20,0,-5]) scale ([8,4,1]) cube (10,center=true);
5. Derniers rajouts
Par la suite, nous ajoutons trois rebords rectangulaires sur chaque sphère avec scale, translate et rotate (voir capture d'écran précédente). Puis, nous venons créer un grand module "avion" englobant toutes les modélisations précédentes, et l'incluons dans une nouvelle différence avec deux cubes aplatis à 45° selon z, venant ainsi former les pics triangulaires sur la plateforme arrière formée plus tôt. L'objectif de ce module est de pouvoir sculpter la plateforme, les sphères arrières ainsi que les entrées d'air en une seule fois, en évitant la modélisation de trois fonctions différences par bloc et donc de considérablement allonger le code.
 //rebords arrières
 translate ([-48,11.8,3.2]) rotate ([0,-10,0]) scale ([4,0.3,0.2]) cube (5,center=true);
translate ([-48,-11.8,3.2]) rotate ([0,-10,0]) scale ([4,0.3,0.2]) cube (5,center=true);
translate ([-48,-4.1,3.2]) rotate ([0,-10,0]) scale ([4,0.28,0.2]) cube (5,center=true);
translate ([-48,4.1,3.2]) rotate ([0,-10,0]) scale ([4,0.28,0.2]) cube (5,center=true);
translate ([-38,8,5]) rotate ([0,0,90]) scale ([1.8,0.3,0.2]) cube (5,center=true);
translate ([-38,-8,5]) rotate ([0,0,90]) scale ([1.8,0.3,0.2]) cube (5,center=true);
 }; 
 
 difference () { 
avion();
 translate ([-63,8,1]) rotate ([0,0,45]) scale ([5,6,2]) cube (4,center=true);
translate ([-63,-8,1]) rotate ([0,0,45]) scale ([6,5,2]) cube (4,center=true);
Enfin, nous plaçons le cockpit avec une sphère allongée légèrement inclinée :

//cockpit
translate ([55,0,4]) rotate ([0,10,0]) scale ([3.2,1.5,1.2]) sphere (3,center=true);
6. Code complet

$fn=100;
 module total() { 
 module avion() { 
//cylindre avant
translate ([39,0,1]) scale ([1,1,0.8]) rotate ([0,90,0]) cylinder (25,8,7.5,center=true);
//pointe centrale
translate ([-2.5,0,1]) scale ([1.5,1,0.8]) rotate ([0,90,0]) cylinder (39,0.1,8,center=true);
module pointeavant() { 
difference () { 
//long cylindre avant
translate ([83,0,-1]) scale ([1,1,0.8]) rotate ([0,100,0]) cylinder (25,7.73,3,center=true);
translate ([67,0,6]) scale ([2,5,5]) cube (5,center=true);
translate ([97,0,6]) scale ([1,5,5]) cube (5,center=true);
};
};
translate ([-20.5,0,0.2]) pointeavant();
//pointe tête
translate ([77,0,-2.3]) scale ([1,1,0.8]) rotate ([0,90,0]) cylinder (6,3.2,0.1,center=true);

//plateforme arrière
translate ([-40,0,1]) scale ([1,1,0.06]) cube (27,0.1,6,center=true);
//cockpit
translate ([55,0,4]) rotate ([0,10,0]) scale ([3.2,1.5,1.2]) sphere (3,center=true);
 
//dérive
module derive() { 
difference () {
translate ([-43,25,0]) scale ([4,5,0.25]) cube (9,center=true);
translate ([-8.5,35,0]) rotate ([0,0,27]) scale ([6,10,2]) cube (9,center=true);
translate ([-74,35,0]) rotate ([0,0,-32]) scale ([4,7,2]) cube (9,center=true);
translate ([-50,50,0]) scale ([4,2,2]) cube (9,center=true);
translate ([-82,10,0]) rotate ([0,0,27]) scale ([6,7,2]) cube (9,center=true);
translate ([-45,5,0]) scale ([7,2,2]) cube (9,center=true);
 }; 
 };
translate ([0.5,1,-7]) rotate ([35,0,0]) derive();
translate ([0.5,-1,-7]) rotate ([145,0,0]) derive();

//grandes ailes
difference () { 
translate ([0,0,1]) scale ([30,25,0.5]) cube (4,center=true); 
translate ([52,30,0]) rotate ([0,0,35]) scale ([6,10,2]) cube (9,center=true);
translate ([52,-30,0]) rotate ([0,0,-35]) scale ([6,10,2]) cube (9,center=true);
 translate ([-52,30,0]) rotate ([0,0,-35]) scale ([6,10,2]) cube (9,center=true); 
 translate ([-52,-30,0]) rotate ([0,0,35]) scale ([6,10,2]) cube (9,center=true); 
 translate ([0,-70,10]) scale ([6,10,5]) cube (4,center=true); 
translate ([0,70,10]) scale ([6,10,5]) cube (4,center=true); 
}; 
//entrée d'air
module entree1() { 
 minkowski ()
 { 
translate ([0,-15,-3.2]) scale ([18,2.2,1.2]) rotate ([0,2,0]) cube (4,center=true);
cylinder (r=2,h=2,center=true); 
 };
 };
module entree2() { 
 minkowski ()
 { 
translate ([0,-15,-3.2]) scale ([18,2.2,1.2]) rotate ([0,2,0]) cube (2.5,center=true);
cylinder (r=2,h=2,center=true); 
 };
 };
difference () { 
translate ([-14,6,3]) rotate ([0,5,-10]) entree1(); 
translate ([2,3.2,1.7]) rotate ([0,5,-10]) entree2(); 
translate ([-17,0,6]) scale ([10,7,1.2]) cube (8,center=true);
};
 difference () { 
translate ([-19,23.5,3]) rotate ([0,5,10]) entree1(); 
translate ([-0,26.8,1.3]) rotate ([0,5,10]) entree2(); 
translate ([-17,0,6]) scale ([10,7,1.2]) cube (8,center=true);
};
//partie supérieure
difference () { 
translate ([-28,8,1.5]) scale ([6,1.2,0.9]) rotate ([260,0,0]) sphere (6,center=true);
translate ([-28,8,7]) scale ([9,1.7,0.5]) cube (6,center=true);
translate ([-60,0,0]) scale ([2,4.5,2]) cube (6,center=true); 
translate ([-50,8,6]) rotate ([0,-10,0]) scale ([5,2.5,1]) cube (6,center=true);
//creux
translate ([-47,8,3]) scale ([3,0.8,0.5]) cube (8,center=true);
translate ([-35,0,-2]) scale ([4,4,0.5]) cube (10,center=true); 
translate ([-20,0,-5]) scale ([8,4,1]) cube (10,center=true);
//retraits bordures arrières
translate ([-43,16,2]) scale ([7,1,1]) cube (4,center=true);
}; 
difference () { 
translate ([-28,-8,1.5]) scale ([6,1.2,0.9]) rotate ([260,0,0]) sphere (6,center=true);
translate ([-28,-8,7]) scale ([9,1.7,0.5]) cube (6,center=true);
translate ([-60,0,0]) scale ([2,4.5,2]) cube (6,center=true); 
translate ([-50,-8,6]) rotate ([0,-10,0]) scale ([5,2.5,1]) cube (6,center=true);
//creux
translate ([-47,-8,3]) scale ([3,0.8,0.5]) cube (8,center=true);
translate ([-35,0,-2]) scale ([4,4,0.5]) cube (10,center=true); 
translate ([-20,0,-5]) scale ([8,4,1]) cube (10,center=true);
 //retraits bordures arrières
 translate ([-43,-16,2]) scale ([7,1,1]) cube (4,center=true);
}; 
//rebords arrières
translate ([-48,11.8,3.2]) rotate ([0,-10,0]) scale ([4,0.3,0.2]) cube (5,center=true);
translate ([-48,-11.8,3.2]) rotate ([0,-10,0]) scale ([4,0.3,0.2]) cube (5,center=true);
translate ([-48,-4.1,3.2]) rotate ([0,-10,0]) scale ([4,0.28,0.2]) cube (5,center=true);
translate ([-48,4.1,3.2]) rotate ([0,-10,0]) scale ([4,0.28,0.2]) cube (5,center=true);
translate ([-38,8,5]) rotate ([0,0,90]) scale ([1.8,0.3,0.2]) cube (5,center=true);
translate ([-38,-8,5]) rotate ([0,0,90]) scale ([1.8,0.3,0.2]) cube (5,center=true);
 }; 
difference () { 
avion();
 translate ([-63,8,1]) rotate ([0,0,45]) scale ([5,6,2]) cube (4,center=true);
translate ([-63,-8,1]) rotate ([0,0,45]) scale ([6,5,2]) cube (4,center=true);
}; 
 };
color("#FABBF4") total();

mars 2024
Boitier capteur + Glissière

Boitier Capteur

Informations

Léa BOUBLIL
lea.boublil@sorbonne-universite.fr
L2 CMI Mécanique
28/03/2024

Contexte
Le boitier de capteur et la glissière ont été modélisé dans le cadre de l'UE conception d'un robot ROMARIN, sur le projet Glider.

Objectifs
Le boitier doit être totalement étanche quand on rajoute un joint (d'étanchéité hein). Il y a les support de capteur qui sont censé être aux bonne dimension pour maintenir les capteur sur le boitier.
On a ajouté une glissière pour pouvoir utiliser le boitier sur d'autre projet que le Glider. Il faut minimiser son volume pour éviter qu'elle agisse comme un flotteur tout en restant assez solide pour maintenir le botier en cas de colision.
Je vais rajouter les pièce en version CatPart (pour qu'elle puissent être modifié) et stl (pour imprimer le modèle actuelle)
Pour l'instant il manque le couvercle de protection qui permettra de protégé les capteurs dans l'eau
Matériel

Impression filament

Machines utilisées
Imprimante 3D du FabLab
Construction
Modélisation sur Catia, puis impression.
Faire des trou pour faire passer les câbles, collage des supports, ajout du joint  et du mastique pour l'étanchéité et des vis pour resserrer le boitier.

création figurine Onigiri



Informations

Adrien DIDIER
adrien.didier8@gmail.com
actuellement en M1 de mathématiques et Applications
début : 03/04/2024 ; fin prévue : 05/04/2024

CONTEXTE
Pour un projet personnel (avril 2023), j'ai décidé d'imprimer en 3D avec du filament noir et blanc une figurine d'Onigiri. Ce projet n'avait pas d'objectif particuliers si ce n'est que de me familiariser au mieux avec les imprimantes 3D du FabLab, et offrir cette figurine à une amie. Voici une capture d'écran de la figurine.

la figurine est composée d'une base pour le corps (prévu en fil blanc ), et de différents accessoires (prévus en fil noir)
 

Matériel

probablement PLA noir et blanc

Machines utilisées
machine 3d PLA

Étape 1
modélisation de la figurine
Étape 2
impression 3D

Gyroscope New Phyrexia

Informations

Milo Reiss Ramdani Medhurst
b.rmmedhurst@gmail.com
CMI Physique
21/04/2024

Contexte
Je suis un grand fan et joueur du jeu de carte Magic: The Gathering depuis mes 8 ans. Mes créature préférées dans l'univers de ce jeux de cartes sont les phyrexians. Donc en vu de mon UE SXPFL et de ma passion pour l'astrophysique, j'ai décidé de travailler sur un projet 3d qui regroupe ces deux passions.

Objectif
Créer un gyroscope (non fonctionnel) sous le theme de la New Phyrexia.

Matériel

PLA

Machine utilisée

Imprimantes Raise3D Pro2

Réalisation

Ouvre OpenScad :

Le symbol Phyrexian :

cylinder(150,0,0)

Tout d’abord, tu commences par faire un symbole phyrexian. Simple, tu vas créer un cylindre de rayon 4 et de hauteur 150.

Pour faire apparaitre le cercle, tu fais la difference entre un cercle de rayon 50 et un cercle de rayon 45, comme ca tu as ton cercle creux fin. Puis tu le fais tourner de 90 degrés selon z et tu le remonte jusqu’a la moitié de la hauteur du cylindre.

difference(){
rotate([90,0,0])

translate([0,75,0])circle(50);
rotate([90,0,0])

translate([0,75,0])circle(45);
}

Ok, maintenant tu as ton symbole phyrexian en 2d erigé vers le haut. Mais en effet il y a un tout petit probleme. Généralement le symbole fait des “vagues” selon le cylindre (personellement je prefere quand il n’y a pas de vagues, ca fait plus Elesh Norn) mais ici on vas ajouter les vagues. Pour ce faire, nous allons soustraire pleins de petites spheres au cylindre. On va soustraire un cercle de rayon 3.7 déplacer de 4 selon l’axe x. Pour les vagues, nous allons faire cela symétriquement selon l’axe x puis diagonallement symétriquement selon l’axe y, en avançant de 4 en 4. Plus simplement le code pour les spheres va ressembler a

translate([(-1)^k *4, 0, 4k])sphere(3.7)

Pour le cylindre en question, le code final ressemble a ceci:
difference(){
cylinder(150, 4, 4);

translate([4,0,0])sphere(3.7);
translate([-4,0,4])sphere(3.7);

translate([4,0,8])sphere(3.7);

translate([-4,0,12])sphere(3.7);

translate([4,0,16])sphere(3.7);

translate([-4,0,20])sphere(3.7);

translate([4,0,24])sphere(3.7);

translate([-4,0,28])sphere(3.7);

translate([4,0,32])sphere(3.7);

translate([-4,0,36])sphere(3.7);

translate([4,0,40])sphere(3.7);

translate([-4,0,44])sphere(3.7);

translate([4,0,48])sphere(3.7);

translate([-4,0,52])sphere(3.7);

translate([4,0,56])sphere(3.7);

translate([-4,0,60])sphere(3.7);

translate([4,0,64])sphere(3.7);

translate([-4,0,68])sphere(3.7);

translate([4,0,72])sphere(3.7);

translate([-4,0,76])sphere(3.7);

translate([4,0,80])sphere(3.7);

translate([-4,0,84])sphere(3.7);

translate([4,0,88])sphere(3.7);

translate([-4,0,92])sphere(3.7);

translate([4,0,96])sphere(3.7);

translate([-4,0,100])sphere(3.7);

translate([4,0,104])sphere(3.7);

translate([-4,0,108])sphere(3.7);

translate([4,0,112])sphere(3.7);

translate([-4,0,116])sphere(3.7);

translate([4,0,120])sphere(3.7);

translate([-4,0,124])sphere(3.7);

translate([4,0,128])sphere(3.7);

translate([-4,0,132])sphere(3.7);

translate([4,0,136])sphere(3.7);

translate([-4,0,140])sphere(3.7);

translate([4,0,144])sphere(3.7);

translate([-4,0,148])sphere(3.7);

translate([4,0,148])sphere(3.7);
}

Le gyroscope: Pour transformer ce beau symbole phyrexian en gyroscope nous allons copier la figure puis la translater jusqu’a la moitié de la hauteur du cylindre, et tourner la nouvelle figure de 90 degrés selon l’axe x. Pour ce nous allons ajouter

“translate([0,75,75])rotate([90,0,0]){“ devant le meme code copié collé.
4. Allez propager la perfection de la New Phyrexia.Modélisation d'une bague

Ayant un membre de ma famille fondeur de bijoux, j'ai décidé de créer une bague pour que mes meilleurs amis et moi-même possèderaient comme signe d'une forte amitié.
Nous sommes donc partis sur un dessin représentant la mer, le soleil et la montagne pour faire référence au département d'où nous venons directement: les Alpes-Maritimes.
Le dessin
Un ami a dessiné sur papier ce dessin:

Maintenant qu'on a ce dessin il faut le vectoriser pour pouvoir l'exploiter sur Fusion, le logiciel que j'utilise pour modéliser la bague.
Il y'a deux solution de vectorisation:

A la main. Il faut donc avoir Adobe Illustrator, et 2 semaines devant soit.
Avec un outil automatique qui utilise de l'IA pour calquer à notre place.

Allons pour l'option 2.
J'ai donc trouvé un outil appelé Vector Magic: https://vectormagic.com/

C'est payant mais franchement j'ai préféré mettre 8 euros que de perdre 2 semaines de ma vie.
Voilà ce qui est sorti de Vector Magic après:

Magnifique.
On a donc notre fichier svg tout propre.
La modélisation
Allons sur Fusion de Autodesk, un logiciel gratuit et beaucoup trop facile d'apprentissage pour l'éviter.
Pour la base de la bague, j'ai suivi un tuto sur Youtube afin d'avoir une idée de quelle stratégie de modélisation adopter: https://www.youtube.com/watch?time_continue=1&v=eTCHK6MBKyI
En suite, après avoir eu la base, j'ai adapté les dimensions et la forme suivant une bague que je possède.
Je suis arrivé à ce premier résultat
Sur cette image, nous voyons le dessin, mais au départ il n'y avait rien sur la face du dessus.
J'ai donc importé le dessin en svg dans Fusion.
Le cauchemar commence
C'est ici que les complications arrivent.

Pour travailler avec un svg dans fusion, il faut l'importer en tant que sketch. Ce sketch va nous permettre de "extrude" dans le "body" afin de graver le dessin dans la bague.
Le problème, c'est que si votre svg est trop compliqué, Fusion ne pourra pas extrude car le nombre de points est trop important et il y'a quelque part dans votre dessin complexe, où les lignes ne forment pas un polygone fermé.
J'ai donc du créer mon propre sketch moi m-même en passant à la main les lignes du dessin.

Chose qui fut quand même pas trop longue et nécessaire car le dessin était de toute façon trop complexe pour une bague de cette dimension. Je rappelle que l'objectif est de l'imprimer en 3D...
Le dessin est maintenant prêt.
J'ai donc pu "extrude", ou graver dans la bague.
J'ai aussi revu la forme et les dimensions de la bague pour arriver à un résultat de la sorte:

Impression 3D
Pour l'impression, je suis d'abord allé voir le Fablab à Escanglon. Ils m'ont redirigé vers l'imprimante résine, beaucoup plus précise et adaptée à ce genre d'impression.
L'imprimante résine se trouve dans le batiment de biochimie au 44 au 2ème étage.

Les deux responsables, dont je ne connais malheureusement pas les noms m'ont très bien accueilli et pris en charge en direct.
J'ai donc fait trois itérations d'impressions pour arriver à ce resultat:

Points d'améliorations
J'aimerais que les rayons de soleil au centre soient plus gravés. C'est compliqué de graver d'avantage sans traverser la bague et former des trous en dessous de la forme sphérique.

Projet théière

Informations

ABBASSI Shérazade
abbassi.sherazade06@gmail.com ou Sherazade.Abbassi@etu.sorbonne-universite.fr
MTX 3 Polytech Sorbonne
30/04/2024 - Date de fin estimée 05/09/24

Contexte
Dans le cadre du projet potentiel entre l'UE de Modélisation et celle de Céramique, nous devons créer un modèle 3D d'un objet donc nous devrons ensuite faire le moule pour enfin le réaliser lors d'un TP Céramique.
Objectifs
Réaliser un modèle 3D puis l'objet fini.

Matériel

Imprimante 3D
Polymère

Machines utilisées

Construction
(Fichiers, photos, code, explications, paramètres d'usinage, photos, captures d'écran...)
Étape 1
----
Étape 2
----
Étape 3
----
Journal de bord

30/04/2024
Premier test d'impression d'un modèle de théière trouvé sur Thingverse : Utah Teapot (teaproof, printable version) https://www.thingiverse.com/thing:1176
Printed in 0.47mm layers, 0.7mm extrusion in PLA with homing on. It needs tightening up a little to be waterproof, and the handle will need to be thickened to take the weight of a full pot.

J'utilise IdeaMaker pour convertir le fichier.

Temps d'impression : 21h-22hProjet: Le prank parfait pour un ami

⚙️ Découpeuse jet d'eau



Profilé en aluminium


Informations

Tancrède SOURICE
tancrede.sourice@gmail.com
ROB
6/03/2023-10/03/2023

Contexte
Volonté de créer un profilé en aluminium 90x56. Ce qui n'est pas une taille standard.

Objectifs
Mon but était de créer un profilé en aluminium à la taille annoncée précédemment et pouvant résister à une charge de 30kg en extension

Matériel

1 plaque de 250x250 e=3mm en aluminium
1 chute d'aluminium 150x250 e=8mm en aluminium
16 vis cHc M3-8
taraud M3
mèche diamètre 2
mèche diamètre 2,5

Machines utilisées
découpeuse jet d'eau
perceuse colonne
Construction
Étape 1
Dessin des différentes pièces sur solidworks. Je joint les DXF : coté.DXFdessous.DXFdessus.DXF
Étape 2
Découpe de ces pièces grâce à la découpeuse jet d'eau

Étape 3
Perçage puis taraudage des montants (Le perçage a été compliqué car les mèches avaient tendance à chauffer et ce malgré l'huile de lubrification. J'ai donc dû passer par 2 diamètres différents.)
Étape 3
Vissage des pièces entre elles puis test de résistance (validé)
U de maintien en rotation

Informations

Tancrède SOURICE
tancrede.sourice@gmail.com
ROB4
15/03/2023-24/03/2023

Contexte
Je veux pouvoir maintenir en rotation un poids de 23kg.
Objectifs
Je cherche à créer un U en aluminium qui maintien une tige d'aluminium de 15mm de diamètre en contact direct. Au bout de cette tige il y aura un poids de 23kg qui est maintenue en rotation de l'autre côté par le même type d'assemblage.

Ajouter au moins une image de votre projet
Matériel

1 plaque d'Alu30 (il s'agit d'une chute que l'on m'a donnée) épaisseur 4mm
1 tige d'aluminium diamètre 17mm
1 circlips
papier à poncer(180-210)
ébavureur

Machines utilisées
Découpeuse jet d'eau
Plieuse manuelle
Tour manuel d'usinage
Construction
Étape 1
Conception du modèle en tôle pliée du U dont voici le DXF : Etat déplié - support bonus.DXF

Étape 2
Usinage de l'axe sur un tour (réalisé en dehors du fablab). Passes rapide puis passe lente de précision et ponçage en 180 puis 210

Étape 3
Découpe au jet d'eau de la plaque

Étape 4
Pliage de la plaque à l'aide d'une plieuse manuelle
Étape 5
Usinage de la gorge pour le circlips sur le tour
Étape 6
Assemblage
Fabrication d'une étoile métallique

Informations

Vincent RIVIERE
v.riviere01@gmail.com
Polytech Sorbonne

Contexte
Pièce pour permettre la translation d'un système mécanique.
Objectifs
Découpe d'une pièce en forme d'étoile sur laquelle sera monté un écrou pour permettre une translation par liaison vis écrou d'un élément d'un système mécanique.

Ajouter au moins une image de votre projet
Matériel

1 plaque d'aluminium de 5mm d'épaisseur
ébavureur

Machines utilisées
Découpeuse jet d'eau
Construction
Étape 1
Modélisation de la pièce

Étape 2
Génération du DXF

Étape 3
Découpe de la pièce

Déformation plastique des kirigami

(Partie de thèse de Joo-Won HONG, actuellement doctorant au PMMH)
Le kirigami est l'art japonais de couper du papier. En science on parle de kirigami dès lors qu'on coupe ou créé des fentes. Ces découpes permettent de rendre par exemple une feuille étirable. On peut utiliser cette méthode pour des lignes "fermées" et ainsi déployer des formes 3D

Dans le cadre de ma thèse, j'essaie de créer un programme permettant d'obtenir un motif de découpe à partie d'une forme 3D cible. Avec ce motif, je peux découper une feuille (de plastique) au cutter laser. Cette feuille, plate au repos se déploie lorsqu'on applique une force vers le haut ou vers le bas pour déployer dans le sens inverse.
Je regarde également la déformation plastique de ses structures dans le but de déployer une forme pour que celle-ci reste dans sa forme déployée

Pour plus d'info: joo-won.hong@espci.fr

Avion en métal


Informations

Tancrède SOURICE
tancrede.sourice@gmail.com
ROB
30/05/2023

Contexte
Volonté de créer un avion en aluminium pour décorer un livre
Objectifs
Mon but est de créer un avion en aluminium grâce à une découpeuse jet d'eau pour ensuite l'insérer dans la couverture d'un livre.

Matériel

1 plaque de 150x120 e=3mm en aluminium

Machines utilisées
découpeuse jet d'eau
Construction
Étape 1
Dessin l'avion sur adobe. Avion.dwg
Étape 2
Découpe de ces pièces grâce à la découpeuse jet d'eau
Étape 3
👕 Textile



Couture de tissu réfléchissant

Objectif:
Le but de mon projet est de coudre un tissu réfléchissant sur un vêtement afin de proposer des vêtements plus visibles la nuit. Cela peut servir pour des organisateurs d’événements afin d’être plus repérable.
Matériel et machines:
-machine à coudre
-tissu réfléchissant (acheté 20 euros sur amazon pour 40 mètres)

Résultat:
La machine à coudre  est vraiment pratique mais la couture prend du temps, au moins pour arriver à maitriser la machine. J'ai pris 3h pour coudre 4 bandes.

Flocage d'un logo SU des fiertés

Introduction
A la suite du mois des fiertés, une membre du personnel SU souhaite personnaliser deux tee-shirts avec un logo SU arc-en-ciel. Il faut pour cela découper chaque tranche de couleur dans un flex thermocollant différent.
Tuto : Clara
Matériel

6 feuilles de flex colorées (une pour chaque couleur de l'arc en ciel)
2 tee-shirts
1 tote bag pour les tests et la démo
1 feuille d'aluminium ou de papier cuisson
1 chute de flex + plastique
1 paire de ciseaux

Machines utilisées

Graphtec cutting pro FC 9000
Presse à chaud

Logiciels

Graphtec Studio 3.0.35gs sur mac (version différente de celle du poste fixe du Fablab)
Inkscape

Préparation du fichier
1. Récupérer le fichier SU au format vectoriel. L'ouvrir dans Inkscape et le redimensionner à la taille désirée.
2. Dessiner les lignes qui serviront de démarcations entre les 6 couleurs. Utiliser le menu 'Aligner et distribuer' pour les répartir verticalement de manière équidistante. On ajuste pour avoir des délimitations sympathique (pas un tout petit bout de flex). Ainsi la tranche du haut et du bas ne feront pas exactement la même épaisseur que les tranches intermédiaires.
3. Créer des rectangles de couleurs de même épaisseur et les faire coïncider avec les lignes avec le magnétisme / bords à bords avec le menu `Aligner et distribuer`. La couleur permet d'aider à visualiser et identifier quelle forme sera découpée dans quel flex, mais n'est pas prise en compte dans le logiciel de découpe
Transformer les rectangles en chemin avec le menu `Chemin > Objet en chemin`
4. Désormais le principe est d'utiliser l'opération booléenne `Intersection` pour trancher le logo en fonction des rectangles. Il est aussi nécessaire de `Dupliquer` les éléments dont on aura besoin plusieurs fois pour faire nos opérations (à commencer par les parties du logo à cheval sur plusieurs tranches). J'ai mis le logo en transparence pour m'aider à voir quand des couches étaient superposées.

5. Mettre le logo en miroir !!

6. Grouper les éléments d'une même tranche ensemble. J'ai ajouté des rectangles autour de chaque partie pour faciliter l'échenillage (c-à-d le retrait du flex que l'on ne voudra pas thermocoller sur le textile). Enregistrer le fichier au format svg pour pouvoir facilement le modifier ultérieurement dans Inkscape, ainsi qu'au format .dxf pour pouvoir l'ouvrir depuis Graphtec Studio.

Découpage
1. Ouvrir le logiciel Graphtec Studio (depuis le poste fixe à côté de la machine ou en le téléchargeant sur votre ordinateur. Remarque : peu de succès en le téléchargeant sur des PC Windows mais aucun problème avec la version Mac)
2. Brancher la machine en USB à l'ordinateur puis allumer la machine.
3. Charger le matériau (cf la page`Utilisation de la Graphtec Pro`) en réglant correctement les roulettes (rappel : les deux roulettes doivent se situer sur une partie antidérapante, ie au niveau des marquages bleus)

4. Ouvrir le fichier .dxf en allant dans `Fichier > Ouvrir` (menu horizontal du haut).

5. Vérifiez les dimensions puis faîtes un clic-droit sur le tracé et allez dans `Scinder tracé composite`, ce afin de pouvoir manipuler chaque tranche indépendamment. (Il aurait aussi été possible d'enregistrer chaque tranche dans des fichiers séparés, mais je préfère ne pas multiplier les fichiers)

6. Positionner la tranche désirée au niveau de l'origine. On peut appliquer une rotation pour optimiser l'utilisation de matériau.
 Dans cette fenêtre, le bord gauche du document correspond au bord bas de la feuille de flex, lorsqu'on fait face à la machine une fois le matériau chargé. Le repère noir correspond donc à une origine (définie manuellement ou automatiquement, cf plus bas) située en bas à droite du travail à effectuer sur la feuille de flex.
 

7. Réglez les paramètres de découpe. Vous n'y arriverez sans doute pas du premier coup car cela dépend de votre matériau ainsi que de l'état de la lame de cutter. Voici ceux qui ont finalement fonctionné pour moi :

8. Lancez un test en allant dans la section `Test de découpe` puis en cliquant sur `Envoyer au cutter`, puis `Démarrer le test`
. 
9. Une fois les bons réglages trouvés (le flex se décolle bien quand on le pèle mais le plastique transparent n'est pas coupé), on peut lancer la découpe de nos motifs, feuille par feuille.
Flocage
1. Avant de floquer votre design final, faîtes un test avec votre flex, si possible sur le textile que vous allez personnaliser, ou au moins sur un textile de composition similaire. Avec ce test, vous allez estimer le temps nécessaire de pressage à chaud pour que le flex adhère au tissu. Nous avons floqué deux textiles différents, un tote bag en coton et des tee-shirts en mélange coton / synthétique, pour lesquels nous avons appliqué le même temps de chauffe et la même température. Il est conseillé de se référer aux instructions du vendeur pour connaître les temps, températures, textiles compatibles, type de pelage (à froid ou à chaud).
Réglage utilisé : 50 secondes à 300°
Une fois le test réalisé, on peut passer au flocage de notre motif.
2. Echenillez les parties qu'on ne souhaite pas floquer (le fond du rectangle, pour ne laisser que le flex utile) pour la première tranche (flex rouge).

 

(Illustrations ci-dessus sont pour la tranche orange)
3. Découpez le rectangle avec une paire de ciseaux

4. Positionnez celui-ci sur le textile - le plastique transparent est collant et va vous aider à placer le motif temporairement.

5. Allumez la presse à chaud, soulevez en le couvercle et faîtes-le tourner pour pouvoir placer votre textile à plat (sur la mousse rouge). Attention, ne manipulez que les poignées pour ne pas vous brûler !

6. Placez une feuille d'aluminium ou de papier cuisson au dessus du textile

7. Abaissez le couvercle sur la feuille d'aluminium et laissez le temps nécessaire (cf tests au point 1). La presse du Fablab a un compte à rebours qui peut être réinitialisé et lancé à l'aide de la flèche vers le bas. Ici nous avons laissé 50 secondes de décompte à 200°C avant de retirer le tout.

8. Retirez le textile et vérifiez que le flex a bien adhéré en décollant légèrement et soigneusement le plastique transparent. Si ce n'est pas le cas, vous pouvez remettre le tissu dans la presse encore quelques secondes.

9. Continuez de façon similaire pour les autres tranches en les alignant les unes en dessous des autres
Important : voici les choses à garder en tête !!
Vérifiez que le flex précédemment collé est toujours protégé par un plastique transparent, et non en contact direct avec l'aluminium
Vérifiez que vous appliquez les nouvelles couches de flex directement sur le textile et non sur un précédent morceau de plastique transparent.
Autrement dit, vous pouvez soulever le plastique de la tranche rouge déjà collée, placer la couche orange, rabattre le plastique de la tranche rouge sur la tranche orange, placer l'aluminium et presser, et ainsi de suite.

 

Une autre possibilité serait de recouper strictement chaque rectangle exactement au niveau des bordures supérieures et inférieures de chaque motif et de tous les presser simultanément (non testé)
Ou encore de décoller chaque petit rectangle progressivement et d'utiliser un  grand plastique vierge pour protéger le tout (non testé)
10. Pour finir, on décolle les petits rectangles de plastique et on fait un dernier passage - toujours idéalement en protégeant l'ensemble du flex avec un grand morceau de plastique transparent.Remarque: nous avons fait des essais avec un transparent type rétroprojecteur, le premier a bien fonctionné mais le deuxième a trop chauffé l'un des morceaux de flex. Utilisez plutôt le plastique qui est au dos du flex, quitte à couper un rectangle de flex + plastique dans une chute et à en retirer le flex.

Fierté !

Fichiers sources
Les fichiers sources sont joints à cette page (menu latéral). Bonne fabrication !
Envie de partager des photos de votre propre réalisation, ou de contribuer à améliorer le processus ? N'hésitez pas à apporter des ajouts à cette page en vous connectant en SSO !Flocage


Informations

Rémi Xi
22 Septembre

Contexte
Flocage textile sur une réplique d'un maillot de club de foot.
Objectifs

Matériel

1 tee-shirt
1 feuille d'aluminium ou de papier cuisson
1 chute de flex + plastique
1 paire de ciseaux

Machines utilisées

Graphtec cutting pro FC 9000
Presse à chaud

Construction
Étape 1
Délimiter les contours et exporter en fichier svg.
Étape 2
----
Étape 3
----
Journal de bord

Couture de la poche d'une veste

🗜️ Outillage à bois et outils manuels



Applique murale Muji hack

Informations

Clara
Fablab
26/08/2022

Contexte
Besoin d'une lampe murale pour pallier la disparition d'une table de chevet. On connaît peut-être les ikea hack, voici un muji hack à partir d'une corbeille en PP. [Muji est une marque japonaise d'articles pour la maison de style plutôt minimaliste]
Objectifs
Créer rapidement une applique murale simple en détournant une boîte en PP muji afin d'en faire un abat-jour, si possible sans la détruire / l'endommager pour qu'elle puisse avoir une seconde vie.

Cosy 8-)
Matériel

1 boîte en PP Muji "corbeille à poignées" taille 15x22x8,6 cm (ou équivalent)
1 équerre en bois avec un côté de 15 cm (l'autre est scié à environ 8 cm, j'ai récupéré ce qui traînait chez moi). J'utilise une équerre trouvée à Leroy Merlin de cette gamme
1 douille E27
1 interrupteur
1 prise
3 m de câble textile 2 fils (ce genre)
1 ampoule E27
2 chevilles 6mm + vis

Outils

Scie à onglet
Perceuse manuelle + mèche à bois 8mm + forêt béton 8mm (éventuellement : visseuse / embout)
des tournevis pour monter le luminaire
pistolet à colle
gants de bricolage
marteau
niveau à bulles
optionnel : multimètre

Construction
étape 1
Voilà en gros l'assemblage qu'on veut obtenir

On commence par positionner la boîte sur l'équerre pour voir à quel niveau on va couper l'équerre. Il faut qu'elle arrive au ras de la façade du fond de la boîte. Il faut essayer d'imaginer qu'on puisse changer l'ampoule une fois l'équerre fixée au mur, donc ne pas trop serrer l'abat-jour à la partie verticale de l'équerre.
On marque le repère au crayon puis on coupe l'équerre avec la scie à onglet ou une scie à bois manuelle.
   
On indique l'emplacement où il va nous falloir percer pour passer le câble. Vu l'épaisseur de mon câble j'ai utilisé une mèche à bois de diamètre 8mm.
 

C'est tout pour la partie à l'atelier du Fablab ! Il ne reste plus qu'à assembler la partie luminaire, fixer l'équerre au mur et faire tenir le tout ensemble !
étape 2

On assemble la partie luminaire :

Couper le câble en deux selon l'endroit où on veut positionner l'interrupteur
Passer le câble côté douille (pour moi le plus court) dans le trou de l'équerre puis dans la poignée de la boîte
Assembler la douille
A l'autre extrémité du même câble, dénuder de la gaine et un peu des deux fils et visser l'interrupteur (éventuellement on peut préalablement repérer avec un multimètre quelle est la position ON de l'interrupteur pour l'assembler dans le sens le plus logique pour soi)
Dénuder l'autre câble et visser d'un côté à l'interrupteur, de l'autre à la prise
Visser une ampoule E27 et tester !

étape 3

Repérer la position de la lampe sur le mur en s'aidant d'un niveau. Marquer au porte-mines l'emplacement des trous de l'équerre
Percer avec un forêt béton adapté aux chevilles (dans mon cas 6mm)
Placer les chevilles et les enfoncer avec un marteau
Positionner l'équerre et les vis, puis visser l'équerre ! A ce stade la partie lumineuse + abat-jour pendouille

Il ne reste plus qu'à positionner la boîte puis tirer le câble pour que la douille soit plaquée contre la boîte et tester l'ambiance
Si tout a l'air bon, on met des gants et branche le pistolet à colle, puis on met un bon trait de colle chaude sur le bas de l'équerre (en-dessous de la boîte) et sous le culot de la douille. On maintient comme on peut et avec un peu de chance, c'est fini !
Dans une V2 il faudrait créer de petits éléments pour améliorer le maintien de la douille et de la boîte

Photos

Boulon denté pour extrudeur

Création d'un boulon denté qui servira à tirer le filament d'une Prusa Mendel Iteration 2 vers la tête d'impression

NOM : BES de BERC
Prénom : Pierre-Emmanuel
Mail : pierre-emmanuel.bes-de-berc@etu.sorbonne-universite.fr
Bureau : IMPMC - Tour 23 - 23-24-402

Date de début : 2023-12-14
Date de fin : 2023-12-14 (estimée)
Objectifs : Indenté un boulon afin de créer une vis d'entraînement pour un extrudeur à filament
Contexte : Réparation d'une Prusa Mendel Iteration 2

Matériaux / Outils / Machines

Boulon M8 6cm
Dremel
Disque de découpe acier 35mm

Construction :

Liste des éléments de l'imprimante : https://reprap.com/wiki/Prusa_Mendel_(iteration_2)

Détail du boulon indenté : https://reprap.org/wiki/Making_a_Hobbed_Bolt

Fabrication et étapes :

Fixer le boulon dans un étau
Meuler régulièrement tout autour sur une longueur d'1 (un) centimètre au milieu du boulon
Vérifier que l'indentage accroche

⌛ Reverse-ingeneering et hacking



Reverse-ingeneering de la graveuse laser Jinsoku LE1620

Informations

Christian Simon
FabLabSU
Date de fin : 29 avril 2022

Contexte - Motivation
Il s'agit de détourner une CNC peu chère de son usage initial. C'est un point de départ intéressant pour construire des machines 2D+ rapidement : l'électronique et le bâti sont déjà montés, ça permet de faire vite plein de choses.
C'est initialement dans le cadre du projet Pillink que j'y ai pensé. Mais on pourrait également transformer cette découpeuse laser en découpeuse à plasma (ou autre !) avec un effort minimal.
L'étape indispensable est de pouvoir modifier la tête pour contrôler autre chose que le faisceau laser de gravure, sans changer le reste.
Présentation de la machine
C'est graveuse laser à bas-coût que l'on peut trouver sur de nombreux site, dont Amazon, pour 245€ environ, produite par Genmitsu et SainSmart.

Elle est basée sur un contrôleur dont le firmware est basé sur l'open-source grbl.
On peut donc la contrôler avec la plupart des logiciels usuels : LaserGRBL (Windows seulement), Lightburn (non-libre). On pense aussi à UGS (Universal Gcode Sender, libre et multiplateforme).
Références : Le blog Ben Maker
On trouve également quelques “unboxing” sur Youtube, mais ils sont sans intérêt pour la plupart.
Démarche
La puissance du laser est fixée dans le Gcode, qui est transmis au contrôleur, qui envoie un PWM à une carte fille montée sous le bras, qui elle-même contrôle et alimente le laser.
On va donc chercher à exploiter ce PWM pour déclencher d'autres actions : démarrer l'aspiration (ouvrir une électrovanne), actionner un servo-moteur, ouvrir un relais. Les valeurs du PWM étant autant de codes d'actions possible… à la précision et au bruit près !
Décodage d'un PWM
La première étape est d'arriver à décoder un PWM avec un Arduino. La meilleure lecture est le blog de Ben Ripley, qui présente 3 méthodes :

-
Simple, basique avec la fonction pulseIn().
-
Avec des interruptions externes à coups de attachInterrupt().
-
Avec des bibliothèques qui implémentent des fonctions autour de ces interruptions.

Il utilise [PinChangeInt](https://playground.arduino.cc/Main/PinChangeInt/ "https://playground.arduino.cc/Main/PinChangeInt/") mais ont trouve très vite ses évolutions dont [PinChangeInterrupt](https://github.com/NicoHood/PinChangeInterrupt "https://github.com/NicoHood/PinChangeInterrupt"), incluse dans la base de bibliothèques de l'IDE Arduino.
On trouve facilement des exemples de gens l'utilisant, par exemple le blog QuadMeUp de @pspychalski. L'exemple permet de décoder des signaux RC transmis par une télécommande avec un PWM à 50 Hz… La première inconnue est donc la capacité à travailler à plus haute fréquence.
Pour prendre en main cela, on programme un premier Arduino pour générer des PWM de 0 (dutycycle 0%) à 255 (dutycycle 100%), selon une entrée. Le PWM généré par l'Arduino UNO est à 490 Hz, déjà de fréquence plus élevée. Ce PWM est envoyé vers l'Arduino qui décode, et allume des LED selon la valeur décodée.
Lorsque cet ensemble fonctionne, on a le code suivant.
 #include <PinChangeInterrupt.h>

/*
Define pins used to provide RC PWM signal to Arduino
Pins 8, 9 and 10 are used since they work on both ATMega328 and
ATMega32u4 board. So this code will work on Uno/Mini/Nano/Micro/Leonardo
See PinChangeInterrupt documentation for usable pins on other boards 
*/

const byte channel_pin[] = {8, 9, 10}; 
volatile unsigned long rising_start[] = {0, 0, 0}; 
volatile long channel_length[] = {0, 0, 0};

#define led_r 7 
#define led_j 6 
#define led_v 5 
#define led_b 4

int etat;

void setup() { 
 Serial.begin(57600);

 pinMode(channel_pin[0], INPUT); pinMode(channel_pin[1], INPUT); pinMode(channel_pin[2], INPUT);
 pinMode(led_r, OUTPUT);
 pinMode(led_j, OUTPUT); pinMode(led_v, OUTPUT); pinMode(led_b, OUTPUT);
 attachPinChangeInterrupt(digitalPinToPinChangeInterrupt(channel_pin[0]), onRising0, CHANGE); 
 attachPinChangeInterrupt(digitalPinToPinChangeInterrupt(channel_pin[1]), onRising1, CHANGE); 
 attachPinChangeInterrupt(digitalPinToPinChangeInterrupt(channel_pin[2]), onRising2, CHANGE);
 
 digitalWrite(led_r, HIGH); 
 digitalWrite(led_j, HIGH); 
 digitalWrite(led_v, HIGH); 
 digitalWrite(led_b, HIGH); 
 delay(1000); 
 digitalWrite(led_r, LOW);
 digitalWrite(led_j, LOW);
 digitalWrite(led_v, LOW); 
 digitalWrite(led_b, LOW); 
 delay(1000); 
 digitalWrite(led_r, HIGH); 
 digitalWrite(led_j, HIGH); 
 digitalWrite(led_v, HIGH); 
 digitalWrite(led_b, HIGH); 
 delay(1000); 
 digitalWrite(led_r, LOW); 
 digitalWrite(led_j, LOW);
 digitalWrite(led_v, LOW); 
 digitalWrite(led_b, LOW); 
}

void processPin(byte pin) { 
 uint8_t trigger = getPinChangeInterruptTrigger(digitalPinToPCINT(channel_pin[pin]));
 if(trigger == RISING) { rising_start[pin] = micros(); } 
 else if(trigger == FALLING) { channel_length[pin] = micros() - rising_start[pin]; } }

void onRising0(void) { processPin(0); }
void onRising1(void) { processPin(1); }
void onRising2(void) { processPin(2); }

void loop() {
 Serial.print(channel_length[0]); 
 etat=map(channel_length[0], 0, 1000, 1, 5); 
 Serial.print(" | "); 
 Serial.print(etat); 
 Serial.print(" | "); 
 Serial.print(channel_length[1]); 
 Serial.print(" | "); 
 Serial.print(channel_length[2]);
 Serial.println("");
 
 int etat;
 
 void setup() { 
 Serial.begin(57600);
 pinMode(channel_pin[0], INPUT); 
 pinMode(channel_pin[1], INPUT); 
 pinMode(channel_pin[2], INPUT);
 pinMode(led_r, OUTPUT);
 pinMode(led_j, OUTPUT); 
 pinMode(led_v, OUTPUT); 
 pinMode(led_b, OUTPUT);
 
 attachPinChangeInterrupt(digitalPinToPinChangeInterrupt(channel_pin[0]), onRising0, CHANGE); 
 attachPinChangeInterrupt(digitalPinToPinChangeInterrupt(channel_pin[1]), onRising1, CHANGE); 
 attachPinChangeInterrupt(digitalPinToPinChangeInterrupt(channel_pin[2]), onRising2, CHANGE);
 
 /* test */
 digitalWrite(led_r, HIGH); 
 digitalWrite(led_j, HIGH); 
 digitalWrite(led_v, HIGH); 
 digitalWrite(led_b, HIGH); 
 delay(1000); 
 digitalWrite(led_r, LOW); 
 digitalWrite(led_j, LOW); 
 digitalWrite(led_v, LOW); 
 digitalWrite(led_b, LOW); 
 delay(1000); 
 digitalWrite(led_r, HIGH); 
 digitalWrite(led_j, HIGH); 
 digitalWrite(led_v, HIGH); 
 digitalWrite(led_b, HIGH); 
 delay(1000); 
 digitalWrite(led_r, LOW); 
 digitalWrite(led_j, LOW); 
 digitalWrite(led_v, LOW); 
 digitalWrite(led_b, LOW); 
 }
 
 void processPin(byte pin) { 
 uint8_t trigger = getPinChangeInterruptTrigger(digitalPinToPCINT(channel_pin[pin]));
 if(trigger == RISING) { 
 rising_start[pin] = micros(); 
 } 
 else if(trigger == FALLING) { 
 channel_length[pin] = micros() - rising_start[pin]; 
 } 
 }

void onRising0(void) { processPin(0); }
void onRising1(void) { processPin(1); }
void onRising2(void) { processPin(2); }

void loop() {
	Serial.print(channel_length[0]); 
 etat=map(channel_length[0], 0, 1000, 1, 5); 
 Serial.print(" | "); 
 Serial.print(etat); 
 Serial.print(" | "); 
 Serial.print(channel_length[1]); 
 Serial.print(" | "); 
 Serial.print(channel_length[2]);
 Serial.println("");
 
 switch (etat) {
	case 1:
	digitalWrite(led_r, HIGH);
	digitalWrite(led_j, LOW);
	digitalWrite(led_v, LOW);
	digitalWrite(led_b, LOW);
	break;
	case 2:
	digitalWrite(led_r, LOW);
	digitalWrite(led_j, HIGH);
	digitalWrite(led_v, LOW);
	digitalWrite(led_b, LOW);
	break;
	case 3:
	digitalWrite(led_r, LOW);
	digitalWrite(led_j, LOW);
	digitalWrite(led_v, HIGH);
	digitalWrite(led_b, LOW);
	break;
	case 4:
	digitalWrite(led_r, LOW);
	digitalWrite(led_j, LOW);
	digitalWrite(led_v, LOW);
	digitalWrite(led_b, HIGH);
	break;
 }
}

Du Gcode au PWM
Avant de faire interpréter le PWM à l'Arduino désormais programmé, on va vérifier les caractéristiques du PWM qui sort du contrôleur, en fonction des Gcode envoyés.
Hélas, l'interface UGS est incapable (a priori) d'allumer/éteindre/moduler le laser de la machine. Pour trouver les Gcode à envoyer, on a donc recours à Lightburn. La configuration du logiciel pour la Jinsoku-LE1620 est détaillée sur le blog Ben Maker.
On met en place 4 tracés, en définissant 4 lignes à 4 puissances différentes :
Le Gcode est sauvegardé
; LightBurn 1.1.03
; GRBL device profile, absolute coords
; Bounds: X17.22 Y16.41 to X37.78 Y65.59
G00 G17 G40 G21 G54
G90
M4
; Cut @ 100 mm/sec, 20% power
M9
G0 X17.219Y16.408
M3
; Layer C00
G1 Y65.592S200F6000
G1 X20.781
G1 Y16.408
G1 X17.219
; Cut @ 100 mm/sec, 40% power
M9
G0 X23.219Y16.408
; Layer C01
G1 Y65.592S400
G1 X26.781
G1 Y16.408
G1 X23.219
; Cut @ 100 mm/sec, 80% power
M9
G0 X29.219Y16.408
; Layer C03
G1 Y65.592S800
G1 X32.781
G1 Y16.408
G1 X29.219
; Cut @ 100 mm/sec, 100% power
M9
G0 X34.219Y16.408
; Layer C02
G1 Y65.592S1000
G1 X37.781
G1 Y16.408
G1 X34.219
M9
G1 S0
M5
G90
; return to user-defined finish pos
G0 X0 Y0
M2

Pour comprendre ce code, on se reporte à la documentation de grbl, page "Laser Mode".
En examinant le Gcode, on repère des lignes G1 qui sont suivies de SXXX et FXXX. On a en particulier choisi le mode d'opération M3 “puissance constante” (et non M4 modulé en fonction de la vitesse de déplacement). Le code du réglage de la puissance est SXXXX (de 0 à 1000), et F est le “feed-rate”.
Avec Lightburn, on envoie divers séquences, et on observe alors à l'oscilloscope :

séquence envoyée
M3 G1S100F100
M3 G1S400F100
M3 G1S800F100

PWM constaté
10%
40%
80%

observation

Accessoirement, on peut mesurer la fréquence du PWM, qui est 1kHz, conformément d'ailleurs à ce qui est annoncé dans la documentation de grbl.
Décodage par l'Arduino et remontage global
Un point important est d'assurer la continuité des masses sur l'ensemble du montage. Même ainsi les moteurs pas-à-pas génèrent un bruit important sur le PWM que l'on cherche à exploiter.
Je dessine alors un carré avec 4 côtés de couleurs différentes dans Lightburn, j'exporte le Gcode, que j'ouvre avec UGS :
; LightBurn 1.1.03
; GRBL device profile, absolute coords
; Bounds: X20 Y30 to X50 Y60
G00 G17 G40 G21 G54
G90
M4
; Cut @ 100 mm/sec, 20% power
M9
G0 X20Y30
M3
; Layer C00
G1 X50S200F6000
; Cut @ 100 mm/sec, 40% power
M9
G0 X50Y30
; Layer C01
G1 Y60S400
; Cut @ 100 mm/sec, 60% power
M9
G0 X50Y60
; Layer C03
G1 X20S600
; Cut @ 100 mm/sec, 100% power
M9
G0 X20Y60
; Layer C02
G1 Y30S1000
M9
G1 S0
M5
G90
; return to user-defined finish pos
G0 X0 Y0
M2

Voici le résultat (intégration du fichier vidéo uploadé sur Bookstack)

Et encore (fichier vidéo accessible depuis Peertube) :

💍 Bijoux



Création d'un pendentif en impression 3D

Informations générales :
Anicet Bouzier
anicet.bouzier@etu.sorbonne-universite.fr
Cursus : Peip 2
Date du projet : décembre 2022

Logiciel : FreeCAD
Outils : Imprimante 3D

Étapes :
Le but de ce projet est de créer de A à Z un pendentif à offrir. J'ai modélisé entièrement l'objet sur FreeCAD (logiciel gratuit). Le fichier est téléchargeable et modifiable. Image de la modélisation prévue :

Pour avoir une idée de la la taille de l'objet : diamètre du cercle : 58mm, épaisseur : 5mm.
L'objet ne peut pas être plus petit ou plus fin par peur de fragilité.

L'objet sera imprimé par dépôt de filament.
Paramètre du slicer :
Impression : Ultra haute qualité
Hauteur de couche 0.1mm
Adhérence : radeau
Supports : tout
Temps estimé : 2h40
Photo du résultat :

Le résultat est très précis, il n'y a aucun défaut dans l'impression. Le seul problème est au niveau de l'accroche : penser à la faire plus grande pour pouvoir faire passer une chaîne. Mais sinon l'impression est parfaite !Impression test de plusieurs bijoux

Informations

VERSEILS Benjamin
verseils.ben@gmail.com
ROB4

23/11/23

Objectifs
Le But est d'imprimer pour vérifier les dimensions une gamme de bijoux afin de pouvoir les créer en fonderie ultérieurement.

Machines utilisées
Imprimante 3D
🕹️ Commande numérique

Développement et tweak de machines à commande numérique

grblHAL sur Arduino DUE (sans breaking board)

Informations

Thomas Panier
thomas.panier@upmc.fr
Laboratoire Jean Perrin - SU
17-03-2023

Contexte
Détournement d'une fraiseuse 3 axes pour faire le suivi de la nage d'une larve de poisson, en remplaçant le moteur par une caméra
Objectifs
Contrôler des drivers de moteurs pas-à-pas avec un arduino Due et grblHAL en envoyant du g-code. Déterminer s'il est nécessaire d'utiliser une breakout board en plus de l'arduino.

Test avec 1 moteur
Matériel

Ordinateur avec Arduino IDE installé et prise en charge de l'arduino Due
Arduino Due
Driver de moteur pas-à-pas Postep25-256
Alimentation 24V
Petits fils de liaison

Construction
Suivre les indications de cette page https://github.com/grblHAL/core/wiki/Compiling-GrblHAL
Attention au mappage par défaut des pins de sortie. Voir dans /src/my_machine.h quelle board est dé-commentée et voir le fichier xxxx_map.h correspondant. Pour vérification des pins : 
Câbler les pins 'enable', 'dir', 'step' et 'ground' entre l'arduino et le driver Postep à l'aide de la doc : https://www.poscope.com/wp-content/uploads/2022/11/PoStep25-256-UserManualV1.1.pdf
Envoyer des commandes grbl via le moniteur série de arduino IDE. Laisser le Due branché via son port 'programming'.
Journal de bord
Ça m'a pris 2 heures en tout à débugger, avec comme difficulté principale la recherche des pins à utiliser.🥫 Autres



Projet Braille

Réalisation d'une maquette pour un stand de projet personnel :

Réalisation d'1 tiroir : Modele trouvé sur Festi box.

Utilisation :

Plaque MDF 6 mm
Contre plaque 5mm

Machine découpe laser :

Parametre pour découper en 1 trait de coupe : Puissance laser 100 vitesse 0.6

Gravue d'1.5 mm de profondeur realisation de 3 passes  sur du contre plaque de  5mm Puissance de 70 vitesse 0.8
Gravue d'1,5 mm de profondeur 2 passe sur MDF 6 mm puissance 80 vitesse 0.7

05/06/2023 : Realisation de la gravure en profondeur temps de gravure + découpe 1h20 min possibilité d'accélerer le processus mais on à un risque de brulure sur le bois le rendant ainsi illisible par la suite.

Concernant le choix des boites faire attention sur les paramètres de burlage passer à 0.85 pour faire rentrer les crenelles dans leur oppose parfaitement et en aillant juste à mettre un coup de maillet. Sinon on a besoin de refaire la peinture par dessus

Realisatioon d'un Puzzle avec relief :

Utilisation des parametres suivant afin d'avoir une uniformisation des filaments donnant ainsi un rendu très propre pour cela on a aussi utilsé le filement de chez makershop3D "Marble" . Attention changer la temperature de buse et mettre 218 au lieu de 215Stage M2 Chimie, Ingénierie Chimique

Sujet du stage : Montage et mise en route d’un réacteur plasma atmosphérique pour la production de H2 à partir d’alcool.
Stagiaire: Florença Wassolua
Tuteur: Jérôme Pulpytel, Maitre de Conférences HDR
Lieu du stage: Laboratoire Interfaces et Systèmes Electrochimiques-LISE
Durée du stage: 01/2023-07/2023
Le stage se déroulera en deux parties. La première partie consiste à la conception/montage du réacteur et la deuxième partie à l’utilisation du réacteur pour la production de H2.
Activités à réaliser au sein du FABLAB

Découpe laser de 4 plaques (50 mm x 50 mm) de plexiglas de 3 mm d’épaisseur munie d’un trou central (3 mm de diamètre)
Découpe laser de 4 plaques (50 mm x 16 mm) de plexiglas de 3 mm d’épaisseur munie d’un trou (5 mm) centré par rapport à la longueur et situé 2 mm du bord supérieur
Découpe laser de 4 plaques (50 mm x 16 mm) de plexiglas de 3 mm d’épaisseur munie d’un trou (5 mm) centré par rapport à la longueur et situé 5 mm du bord supérieur
Collage de la plaque inférieur avec les côtés, la plaque supérieure doit pouvoir être retirée manuellementFig. Schéma de la conception du réacteur
Caméra Lucida (chambre claire)

L'objectif est de réaliser une chambre claire réglable pour projeter des objets macroscopique afin de les dessiner

Création d'une vitrine pour le Fablab

Informations
•Les médiateurs
•FabLab - Espace Biologie/Chimie
•Début : 23/11/2022

Contexte
Après le déménagement de l'espace Biologie/Chimie du FabLab, la création d'une vitrine a été proposée. Cette vitrine sera composée des créations faites par les emplois étudiants afin qu'ils soient plus à même de montrer les possibilités au sein du FabLab, mais aussi de se former sur des machines et des logiciels disponibles.
Certaines créations à plus grande envergure pourront être étalés dans le temps si besoin, d'où la nécessité de documenter cette page Wiki.

Objectifs
L'objectif de cette vitrine est de pouvoir exposé les possibilités techniques au sein de l'Espace Biologie/Chimie. Chaque création doit donc soit être en lien avec la Biologie ou la Chimie, soit être utile à l'espace.

Journal de Bord
Avancée chronologique des projets et idées, difficultés rencontrées, modifications et adaptations
23/11/2022
Création de la page Wiki associée au projet de vitrine.
La première idée est de créer quelque chose en résine grâce à l'impression résine. Il est possible de trouver des idées sur le site : thingiverse.com .

Pour faire une impression résine, il est nécessaire d'utiliser le logiciel Chitubox. Un tutoriel est dispo sur ce wiki ici : utilisation-basique-de-chitubox-pour-limpression-resine.
Le premier objectif est de trouver une idée pour l'impression résine et de faire un crash test du tutoriel associé, où le médiateur devra utiliser l'impression résine tout seul afin d'amélioré le tuto.
Première idée pour l'impression résine : un mur végétal.

https://www.thingiverse.com/thing:2821494
https://www.thingiverse.com/thing:1606962
https://www.thingiverse.com/thing:2763587
https://www.thingiverse.com/thing:532091
https://www.thingiverse.com/thing:4365991
https://www.thingiverse.com/thing:603982 <3
https://www.thingiverse.com/thing:5619468
https://www.thingiverse.com/thing:5638637 (puzzle de cerveau)

Anthotypes au curcuma

Informations

Clara Devanz
FablabSU
octobre 2023

Contexte
Utilisation de l'insoleuse à UV dans la salle de préproduction de l'espace Prototypage pour réaliser des anthotypes au curcuma
Objectifs
Faire des premiers essais d'anthotypes au curcuma pour se familiariser avec le procédé, avant d'envisager des expérimentations avec d'autres masques réalisés avec des procédés d'usinage numérique (par exemple découpe laser / plotter de découpe)

Matériel

1 plaque de PMMA coulé 300*280mm, 3mm d'épaisseur
1 plaque de MDF 300*280mm, 3mm d'épaisseur
poudre de curcuma
alcool IPA
feuilles de papier aquarelle
pinceau plat large
herbes aromatiques fraîches
pinces
vaporisateur en plastique
bicarbonate de soude
eau
cuiller, spatule plastique, 2 pots en verre
masque FFP2
élastiques en caoutchouc
gants jetables en nitrile
blouse
papier journal pour protéger le plan de travail

Machines utilisées

Trotec Speedy 100
Insoleuse à UV

Procédé
Étape 1

Découpe d'une plaque de MDF et d'une plaque de PMMA 3mm de dimensions 30*28mm à l'aide de la trotec speedy 360 (paramètres usuels de la bibliothèque FABLAB)

Étape 2

Dans un endroit ventilé / sous une sorbonne, équipé·e d'une blouse et de gants en nitriles, après avoir protégé le plan de travail avec du papier journal
Mélanger une à deux cuillers de poudre de curcuma avec environ 3cL d'alcool IPA dans un bocal en verre. Remuer avec la spatule en plastique pour que la curcumine colore l'alcool.
Pour filtrer le mélange, placer un masque FFP2 (ou filtre à café) au dessus d'un deuxième bocal en verre et le maintenir avec un élastique en caoutchouc. Verser le mélange dans ce filtre.
A l'aide d'un pinceau plat, recouvrir généreusement une feuille de papier aquarelle de la solution à la curcumine une fois filtrée. Faire plusieurs passages dans différents sens pour éviter les traces de pinceau.
Laisser sécher la teinture

 

Étape 3

Poser la feuille de papier colorée teintée et sèche sur le support en MDF
Disposer les masques choisis sur la teinture, pour ces premiers essais il s'agissait d'herbes fraîches.
Placer la plaque de PMMA sur les herbes / masques et placer des pinces pour enserrer la feuille colorée et les herbes entre le MDF et le PMMA.

Étape 4

Placer le tout dans l'insoleuse à UV (face colorée vers les lampes) et lancer l'insoleuse pour un premier cycle (90minutes max sur notre machine)
Notre insoleuse a des lampes relativement espacées, ce qui crée des irrégularités dans l'éclaircissement de la teinture de curcuma. Il faut donc penser à décaler l'assemblage (en x et y) entre les différents cycles
4 à 5 cycles donnent une bonne décoloration du fond à la curcumine. Cela pourrait nécessiter moins avec une insoleuse plus puissante.

 

Étape 5

Quand le fond a bien blanchi, on peut retirer les pinces, la plaque de PMMA et les herbes. La partie occultée par les herbes est restée jaune vif
Pour accentuer le contraste, on va utiliser une solution à base de bicarbonate de soude. On mélange environ une cuiller à soupe avec de l'eau tiède dans un pulvérisateur en plastique
On pulvérise l'image à bonne distance : les couleurs changent progressivement. On peut pulvériser l'image uniformément ou en favorisant certaines zones. Etre prêt·e à prendre des photos de l'évolution des couleurs !

Remarques

Comme les substances sont photosensibles, l'image sera éphémère. Il convient néanmoins de la stocker à l'abri de la lumière pour allonger sa durée de vie.
Quelques heures d'exposition à un vif soleil peut tout à fait remplacer l'insoleuse à UV
Poursuite des expérimentations : Il pourrait être intéressant de créer des masques de transparences différentes, et/ou positionnés à différentes distances de la feuille, pour créer des effets d'ombrage. Des images imprimées en négatif sur feuilles transparentes type rhodoïd sont traditionnellement utilisées pour les anthotypes et cyanotypes, on pourrait mélanger différentes façons de masquer la lumière.

💵Projet Cours de Gestion Financière pratique pour Etudiants

Dans un monde où la maîtrise de l'argent est essentielle à une vie équilibrée et épanouissante, ce cours de Gestion Financière Pratique s'érigerais comme un guide pour les étudiants.
L'objectif serais de les armer de connaissances et de compétences pratiques, pour pouvoir naviguer habilement dans le dédale des décisions financières, qui la plupart du temps laissent les étudiant en banqueroute.
De la budgétisation quotidienne à la planification d'investissements à long terme, ce cours viserais à fournir une feuille de route complète, permettant aux étudiants de prendre le contrôle de leur vie financière. En développant une compréhension approfondie des principes de la gestion financière personnelle, les participants seront équipés pour prendre des décisions éclairées et proactives, posant ainsi les bases d'une vie financière solide et durable.
I. Introduction : Comprendre et Maîtriser l'Art de Gérer son Argent
Dans ce cours, nous nous proposons d'équiper les étudiants des compétences essentielles pour comprendre, dépenser judicieusement et maximiser la valeur de leur argent au quotidien. En mettant l'accent sur la gestion financière pratique, ce cours vise à offrir une perspective holistique sur la manière de prendre des décisions éclairées en matière d'argent.
II. Module 1 : Les Bases de la Gestion Financière Personnelle
Dans cette première section, les étudiants seront initiés aux concepts fondamentaux de la gestion financière personnelle, tels que la budgétisation, l'épargne, et l'établissement d'objectifs financiers. Des discussions interactives et des exercices pratiques les aideront à élaborer un plan financier personnel adapté à leurs besoins et aspirations.
III. Module 2 : Stratégies d'Économie au Quotidien
Ce module se concentrera sur des astuces pratiques pour économiser de l'argent au quotidien, en mettant particulièrement l'accent sur les dépenses courantes comme les courses alimentaires. Les étudiants apprendront à optimiser leur budget alimentaire, à repérer les offres et à adopter des habitudes d'achat intelligentes.
IV. Module 3 : Gérer les Dépenses Liées aux Études
Puisque les étudiants sont au cœur de ce cours, ce module explorera des stratégies spécifiques pour gérer les dépenses liées aux études, y compris les livres, le logement, et les frais de scolarité. Des conseils seront dispensés pour maximiser la valeur des investissements dans l'éducation.
V. Module 4 : Investir pour l'Avenir
Ce module introduira les étudiants aux principes de base de l'investissement. Ils apprendront à comprendre les différents véhicules d'investissement, à évaluer le niveau de risque, et à élaborer une stratégie d'investissement alignée sur leurs objectifs à long terme.
VI. Module 5 : Gestion des Dettes et du Crédit
La gestion des dettes et du crédit est une compétence cruciale. Dans cette section, les étudiants exploreront comment utiliser le crédit de manière responsable, gérer les dettes étudiantes, et élaborer des stratégies pour rembourser efficacement les prêts.
VII. Module 6 : Planification Budgétaire pour les Projets Spécifiques
En se concentrant sur la planification budgétaire à court terme, ce module aidera les étudiants à élaborer des budgets pour des projets spécifiques tels que les voyages, les événements spéciaux, ou les achats importants. Des conseils pratiques sur la manière de rester fidèle à son budget seront également partagés.
VIII. Conclusion : L'Avenir Financier en Main
Le cours se conclura en rappelant l'importance de la gestion financière continue et en fournissant des ressources pour soutenir les étudiants dans leur parcours financier. Les compétences acquises dans ce cours les prépareront à prendre des décisions financières éclairées tout au long de leur vie.

Utilisation de la Graphtec avec l'outil porte-stylo

Introduction
Nous avons l'habitude au Fablab SU d'utiliser la Graphtec avec l'outil lame, afin de découper du vinyle ou du flex. Cependant comme la majorité des plotters la machine permet aussi de tracer des formes vectorielles avec un stylo sur papier (voire textile). Un outil porte-feutre 'felt-tip' est fourni avec la machine. Cependant il est censé être utilisé avec un type de feutre bien particulier. Une façon de détourner l'outil est d'utiliser une pointe de stylo (sans le corps du stylo) et d'enrouler du scotch de peintre pour pouvoir la maintenir.

Tracé à partir d'un design génératif
Pour ces essais j'ai utilisé un design que j'avais codé en javascript grâce à p5js, adapté à partir d'équation de tuiles de Truchet.
Voici la page vers l'éditeur p5js.
Le code est le suivant :

//Truchet tiles in SVG
//Inspired from:
//https://openprocessing.org/sketch/505865/
//itself inspired by:
//Truchet tiles in 2D
//http://paulbourke.net/geometry/tilingplane/index.html#truchet
//SVG conversion thanks to: https://github.com/zenozeng/p5.js-svg
//Don't forget to add <script src="https://unpkg.com/p5.js-svg@1.3.1"></script> in your index.html.
//Directly save the generated svg and downloads it if you uncomment the instruction 'save()'

//number of tiles in one side
var numTiles = 16;
var sizeTile;
var tiles = [];

const a=1;
const b=0.7;
const c=1.3;

function setup() {
	createCanvas(windowHeight, windowHeight, SVG);
	background(0);
	sizeTile = width / numTiles;
	colorMode(RGB, 255);
	noFill();
	for (var i = 0; i < numTiles; i++) {
		for (var j = 0; j < numTiles; j++) {
			tiles.push(new Tile);
			tiles[j + i * numTiles].x = j * sizeTile + sizeTile / 2;
			tiles[j + i * numTiles].y = i * sizeTile + sizeTile / 2;
			tiles[j + i * numTiles].col = [2 * j, 0.8 * i];
		}
	}
}

function draw() {
 background(255, 250, 244);
	for (var i = 0; i < numTiles * numTiles; i++) {
		tiles[i].display();
		if (random() < 0.002) {
			tiles[i].rotating = true;
		}
	}

 if (i > numTiles) {
 noLoop();
 save(); // comment if you don't want to save the generated svg
 }
}

//x,y: coordinates of the center of the tile, r:width of the tile
function Tile() {
	this.x;
	this.y;
	this.r = a*sizeTile;
 this.r2 = b*sizeTile;
 this.r3 = c*sizeTile;
	this.orientation = random();
	this.rotation = 0;
	this.rotating = false;
	this.display = function() {
	push();
 translate(this.x, this.y);
 noFill();
 stroke(55, 10, 10);
 strokeWeight(2);
 
		if (this.orientation > 0.5) {
			arc(-this.r / 2, -this.r / 2, this.r, this.r, 0, PI / 2);
			arc(this.r / 2, this.r / 2, this.r, this.r, -PI, -PI / 2);
 arc(-this.r / 2, -this.r / 2, this.r2, this.r2, 0, PI / 2);
			arc(this.r / 2, this.r / 2, this.r2, this.r2, -PI, -PI / 2);
 arc(-this.r / 2, -this.r / 2, this.r3, this.r3, 0, PI / 2);
			arc(this.r / 2, this.r / 2, this.r3, this.r3, -PI, -PI / 2); 
		} 
 
 else {
			arc(-this.r / 2, this.r / 2, this.r, this.r, -PI / 2, 0);
			arc(this.r / 2, -this.r / 2, this.r, this.r, PI / 2, PI);
 	arc(-this.r / 2, this.r / 2, this.r2, this.r2, -PI / 2, 0);
			arc(this.r / 2, -this.r / 2, this.r2, this.r2, PI / 2, PI); 
 	arc(-this.r / 2, this.r / 2, this.r3, this.r3, -PI / 2, 0);
			arc(this.r / 2, -this.r / 2, this.r3, this.r3, PI / 2, PI);
		}
		pop();		
	}
}
Plus d'informations sur la documentation de ma Fabacademy.
Ce script permet d'enregistrer au format .svg. Il faut ensuite enregistrer le fichier au format .dxf (par exemple en l'ouvrant dans Inkscape), afin de pouvoir ouvrir le tracé dans Graphtec Studio.
Variante : j'ai lancé un deuxième tracé en changeant les paramètres :
a = 1;
b = 0,33;
c = 1,66;
Préparation dans Graphtec Studio
La seule particularité par rapport à l'utilisation de l'outil cutter est de spécifier qu'il faut utiliser l'outil stylo. J'ai utilisé les préréglages proposés mais il est possible de modifier vitesse, accélération et force.

Préparation du stylo
J'ai retiré la mine du corps, puis ajouté une épaisseur de scotch afin de pouvoir serrer la pointe dans l'outil. J'ai utilisé d'abord une mine de bic noir, puis des mines turquoise et rouge de stylo gel 0.5mm MUJI.

 

On insère ensuite la pointe dans le porte-outil (la bague du haut doit être desserrée). Sur cette photo le porte-outil est déjà clipsé dans l'outil de réglage de la hauteur de la pointe.
On ajuste la pointe sur le bas de l'outil de réglage de la hauteur, puis serre la bague.

 

On place le porte outil dans la graphtec et serre le gros écrou devant

Lancement du travail
Après avoir mis la feuille, ajusté les molettes, chargé le matériau (3-Feuille), on lance le travail depuis Graphtec Studio (Envoyer au cutter)

Avec le bic noir :

Résultats et remarques
J'ai essayé un changement de mine au cours d'un travail en le mettant en pause. Premier essai : la bague du plotter était mal serrée au début (une partie n'est pas tracée)

Pour un deuxième essai j'ai mal centré la pointe rouge lors du troisième passage.

Mise au point milieu de culture bioluminescence

Retour sur la posture lors des activité physique (squate)

Boitier pour Terminal tactile

Modélisation des effondrements et fontis

TIPE Simulateur de Pente : Controle d'un moto-réducteur DC 24V

Arroseur automatique de plantes - Amélioration 2024

Création jeu de l'oie développement durable

Enceinte audio nomade "NOMAUDIO"

Tests de solubilité sur l’aloe-emodine, l’emodine et la rhéine