Projets d'UE 2022-2023

Comment documenter ? [Projets d'UE]

🌡️ UE LU1SXPFL - L1 CMI Physique



Description de l'UE

L'UE LU1SXPFL est une UE d'initiation aux principales techniques utilisées dans les fablabs (conception et fabrication numérique et prototypage électronique) proposée aux étudiants du CMI Physique au niveau L1. L'UE commence par un historique des fablabs, d'où ils viennent, ce qu'on y fait, etc. Suivent, quelques séances de formation aux outils de conception 2d/3d (Inkscape, OpenSCAD, FreeCAD), un introduction aux machines (découpeuse laser, imprimantes 3d) et une initiation au prototypage électronique utilisant des cartes de développement (Arduino Uno, M5Stack) et des modules (capteurs, afficheurs, LEDs, etc.). Le reste du temps est dédié à la réalisation d'un projet au fablab combinant conception - fabrication - prototypage.
Enseignant responsable: Vincent Dupuis
Période et volume horaire: janvier 2023-avril 2023, 30h par étudiant (10 séances de 3h)
Effectifs: L1 CMI Physique, ~ 30 étudiants

Quelques liens:
fablabs.io : carte interactive du réseau international des fablabs, beaucoup d'informations
fabacademy : page de la formation de haut niveau dispensée au sein des fablabs du réseau de janvier à juin. Plus interessant, l'archive des documentations de la fabacademy qui rassemble les documentations des étudiants
quelques sites où l'on trouve un grand nombre de projets documentés : hackster.io,instructables, hackaday.
Groupe B1 - Sonomètre portatif

Membres du groupe : Maïlys HERMANN-BOYER, Shirel FELLOUS, Lily-Rose GAVANON

Page de documentation d'étudiantes en L1 de CMI Physique dans le cadre du Projet Fablab (découverte du Fablab SU & réalisation d'un projet incluant un capteur environnemental) en 10 séances de 3h

Découverte du Fablab

Séance 1 : Introduction à l'UE
Aujourd'hui, ce 23 janvier 2023, nous avons eu la chance de participer à notre premier cours de l'UE Fablab. Cela a été organisé dans l'enceinte du Laboratoire Fablab qui se trouve dans le bâtiment Esclangon de l'université de la Sorbonne. Le Fablab est un atelier créé à l'origine par le professeur Neil Gershenfeld au MIT, dans l'optique de réunir différentes personnes passionnées par la recherche et le développement de créations quelconques. Un réseau mondial de laboratoires s'est donc formé afin de donner accès à des outils de fabrication numérique à de multiples individus.

Nous avons donc pu visiter ce laboratoire et suivre les explications des différentes machines telles que des imprimantes 3D, des fraiseuses numériques ou encore des découpeuses laser.

Notre but dans les séances à venir sera de réfléchir à un projet permettant la création d'un objet utilisable au quotidien. Ce projet devra inclure un ou plusieurs capteurs environnementaux.

Séance 2 : Circuits Arduino et capteurs
Ce lundi 30 janvier, la séance portait sur le prototypage électronique. Nous avons été initiés à l'histoire de l'électronique, du tube à vide en 1904 au M5Stack en 2017 ; nous avons pu voir la chronologie d'apparition des différentes techniques et découvertes électroniques.

Nous avons découvert la carte Arduino, prototypée en 2003 par un étudiant en Master et apparue réellement sous forme de carte en 2005. Ce composant est en fait un microcontrôleur, capable de capter des signaux analogiques (pouvant prendre toutes les valeurs entre 0 et 5 V). Pour programmer un Arduino, il faut utiliser un langage spécifique, écrire un code "IDE Arduino".

Ensuite, nous avons essayé de comprendre le fonctionnement de la carte Arduino, tout d'abord avec un programme permettant de faire clignoter la LED de l'Arduino. Nous avons ensuite essayé de récupérer les données recueillies par un capteur de température et d'humidité. Il fallait tout d'abord placé un Grove Shield sur la carte Arduino afin de pouvoir brancher différents composants. On retrouve sur ce Shield des ports numériques et analogiques, comme sur l'Arduino, mais aussi des ports I2C, que nous utilisons pour relier le capteur à l'Arduino. Le transfert de l'ordinateur à l'Arduino se fait en série.

Afin de pouvoir utiliser un composant particulier, il faut télécharger une bibliothèque associée qui contient toutes les fonctions liées à ce composant. Ces bibliothèques sont facilement trouvables sur Seeed Studio ou en cherchant le nom du composant sur Internet. Pour chaque capteur il peut y avoir une bibliothèque et un port différents. Il faut donc se renseigner sur le Wiki pour avoir les renseignements du capteur utilisé.
Par la suite, nous avons utilisé d'autres capteurs tel qu'un "gas sensor" qui permet de calculer la concentration de CO2 dans l'air afin d'estimer si l'on est dans un environnement nocif ou non. Celui se branche par la connecteur A0.

Nous avons enfin essayé de travailler avec plusieurs composants en cherchant à afficher les valeurs de température et d'humidité enregistrées par le capteur sur un petit écran (16x2 LCD). Pour cela, nous avons essayé de combiner les 2 codes des deux composants utilisés. Après quelques essais, on arrivait à lire les données du capteur en ayant téléversé le code suivant :
#include <Arduino.h>

#include <Wire.h>
#include "SHT31.h"
#include <Wire.h>
#include "rgb_lcd.h"

rgb_lcd lcd;

const int colorR = 209;
const int colorG = 141;
const int colorB = 247;

SHT31 sht31 = SHT31();

void setup() { 

 Serial.begin(9600);

 while(!Serial);

 Serial.println("begin..."); 

 sht31.begin(); 

}

void loop() {

 float temp = sht31.getTemperature();

 float hum = sht31.getHumidity();

    // set up the LCD's number of columns and rows:

   lcd.begin(16, 2);

   lcd.setRGB(colorR, colorG, colorB);

   // Print a message to the LCD.

   lcd.print("Temp = ");

   lcd.print(temp);

   lcd.println(" C"); //"ln" pour retour à la ligne

   lcd.print("Hum = ");

   lcd.print(hum);

   lcd.println("%");

   delay(1000);
}
Nous avons ensuite essayé de réaliser la même chose sur un écran un peu plus complexe, un OLED Display 0.96 inch. Le code était le suivant :
#include <Arduino.h>
#include <Wire.h>
#include "SHT31.h"

SHT31 sht31 = SHT31();

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif

U8G2_SSD1306_128X64_ALT0_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);

void setup() { 

 sht31.begin(); 

 u8g2.begin();
}

void loop() {

 float temp = sht31.getTemperature();

 float hum = sht31.getHumidity();

 u8g2.clearBuffer();                   // clear the internal memory

 u8g2.setFont(u8g2_font_ncenB08_tr);   // choose a suitable font

 u8g2.setCursor(0, 15);

 u8g2.print("temperature = ");

 u8g2.print(temp);

 u8g2.println(" C");

 u8g2.setCursor(0, 30);

 u8g2.print("humidity = ");

 u8g2.print(hum);

 u8g2.println(" %");

 u8g2.sendBuffer();                    // transfer internal memory to the display

 delay(200);
}

Pour conclure, c'était une séance très constructive qui nous a donné différentes idées pour notre projet final.

Séance 3 : Dessin 2D, 3D, impression 3D et découpe laser
Lors de cette séance, nous avons découvert certains logiciels libres et gratuits de dessin et modélisation 3D. Des tutoriels pour chacun de ces logiciels sont disponibles sur le Wiki du FABLAB ou sur Internet.
La logiciel principalement utilisé pour la découpe laser est le logiciel Inkscape. Afin que le dessin réalisé soit exploitable, il faut s'assurer que l'épaisseur du trait soit toujours de 1px. En ce qui concerne la couleur des traits, le rouge correspond à la découpe alors que le noir fait référence à la gravure. Le plus important lors de l'utilisation de ce logiciel est de contrôler les dimensions et le positionnement des différents objets. Le format lu par les découpes laser est le format SVG.
Nous avons réalisé ce dessin lors de notre découverte du logiciel.

Nous avons ensuite été initiées à 2 logiciels de modélisation 3D : OpenSCAD et FreeCAD. Ces logiciels sont utilisés dans le cadre d'impressions 3D. Pour cela, il est important de savoir que le format lu par les imprimantes est le format STL. Nous nous limiterons à l'utilisation du workbench Part dans FreeCAD. Afin de se familiariser avec les outils des deux logiciels, nous avons essayé de réaliser un cube de 50mm de côté troué par 3 cylindres de 20mm de diamètre.
Sur OpenSCAD :
difference() {
 cube(50,center=true);
 translate([0,0,-25]) cylinder(h=50,r=20);
 rotate([90,0,0]) translate([0,0,-25]) cylinder(h=50,r=20);
 rotate([0,90,0]) translate([0,0,-25]) cylinder(h=50,r=20);
}

Nous avons ensuite pu voir un peu plus en détails comment faire fonctionner les différentes machines du FABLAB.

Pour les imprimantes 3D, le logiciel utilisé est IdeaMaker. Il est toujours important de réfléchir au remplissage d'un objet lors de son impression. Il faut aussi penser à l'épaisseur du fil utilisé (+ c'est fin + c'est précis mais + c'est long), à l'orientation de l'objet sur le support.

Séance 4 : Prototypage électronique
Aujourd'hui, nous avons exploré un peu plus en profondeur le prototypage électronique avec un M5Stack.
Le M5Stack est un boîtier programmable avec Arduino IDE, contenant de la mémoire (4Mo), une carte SD et des haut-parleurs. Une sortie I2C permet d'y brancher des capteurs et un port USB-C pour le relier à un ordinateur.
Nous avons commencé par tenter de faire fonctionner le M5Stack avec des programmes exemples trouvés sur GitHub.
En téléchargeant ce fichier ZIP, on accède à la bibliothèque du M5Stack. Nous avons tout d'abord ouvert le programme "Hello World" (examples > basics). Il ne faut pas oublier de sélectionner la board M5Stack Core ESP32 dans Arduino INE ainsi que le bon port.
Nous avons ensuite essayé d’afficher les données d’un capteur de température et d’humidité sur l’écran du M5Stack.
on a téléchargé le fichier ZIP du M5stack puis dans examples > advanced > display > free font demo > on ouvre direct le fichier
#include <Arduino.h>
#include <M5Stack.h>
#include <Wire.h>
#include "SHT31.h"
#include "Free_Fonts.h" 
 
SHT31 sht31 = SHT31();
 
void setup() { 
 Serial.begin(9600);
 while(!Serial);
 Serial.println("begin..."); 
 sht31.begin(); 
 M5.begin(); // Init M5Core. 初始化 M5Core
 M5.Power.begin(); // Init Power module. 初始化电源模块
 
}
 
void loop() {
 float temp = sht31.getTemperature();
 float hum = sht31.getHumidity();
 M5.Lcd.setFreeFont(FSB18);
 M5.Lcd.print("Temp = ");
 M5.Lcd.print(temp);
 M5.Lcd.println(" C");
 M5.Lcd.print("Hum = ");
 M5.Lcd.print(hum);
 M5.Lcd.println(" %");
 M5.Lcd.println(); 
 delay(1000);
}

Projet final
Séance 5 : Première idée de projet final
Nous avons commencé à réfléchir au projet que nous souhaiterions réaliser. Après être tombées sur ce Tiktok, nous avons convenu d'inclure des capteurs de son et des LEDs dans notre projet. Nous voulions à l'origine tenter de reproduire l'objet de la vidéo, avant de vite nous rendre compte que c'était un objet encore bien trop complexe pour nos capacités. Nous avons alors cherché sur Internet des projets utilisant quand même des micros et des LEDs, tout en restant à notre niveau novice. En voici quelques-uns :

Music / hand controlled led strip with arduino
Neopixel Ws2812 Rainbow LED Glow With M5stick-C

À partir de là, nous avons décidé que le but de notre projet serait de contrôler la couleur et la luminosité de LEDs en fonction de la fréquence et l'intensité sonore (donc par exemple avec de la musique).
Nous avons commencé à travailler avec 3 composants :

un capteur de son (micro constitué d'une membrane qui vibre en fonction de la pression acoustique et qui convertit les oscillations en signal électrique)
un capteur de sonie (micro qui isole et amplifie les signaux à haute fréquence)
une barre de LED (10 LEDs RGB indépendantes les unes des autres)

Dans un premier temps, nous avons testé un à un chacun des composants pour comprendre leur fonctionnement.
Nous avons réussi à faire fonctionner les LEDs grâce au code de "Seeedstudio" :
// NeoPixel Ring simple sketch (c) 2013 Shae Erisson
// released under the GPLv3 license to match the rest of the AdaFruit NeoPixel library

#include "Adafruit_NeoPixel.h"
#ifdef __AVR__
 #include <avr/power.h>
#endif

// Which pin on the Arduino is connected to the NeoPixels?
// On a Trinket or Gemma we suggest changing this to 1
#define PIN 6

// How many NeoPixels are attached to the Arduino?
#define NUMPIXELS 10

// When we setup the NeoPixel library, we tell it how many pixels, and which pin to use to send signals.
// Note that for older NeoPixel strips you might need to change the third parameter--see the strandtest
// example for more information on possible values.
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

int delayval = 500; // delay for half a second

void setup() {
 // This is for Trinket 5V 16MHz, you can remove these three lines if you are not using a Trinket
#if defined (__AVR_ATtiny85__)
 if (F_CPU == 16000000) clock_prescale_set(clock_div_1);
#endif
 // End of trinket special code
 pixels.setBrightness(255);
 pixels.begin(); // This initializes the NeoPixel library.
}

void loop() {

 // For a set of NeoPixels the first NeoPixel is 0, second is 1, all the way up to the count of pixels minus one.

 for(int i=0;i<NUMPIXELS;i++){

 // pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
 pixels.setPixelColor(i, pixels.Color(0,150,0)); // Moderately bright green color.

 pixels.show(); // This sends the updated pixel color to the hardware.

 delay(delayval); // Delay for a period of time (in milliseconds).

 }
}

En effectuant différentes modifications sur le code, nous avons pu baisser la luminosité des LED ainsi que changer leur couleur.Pour changer la luminosité : remplacer 255 par une valeur entre 0 et 255 (ligne 29) (ici nous avons choisi 100)Pour changer la couleur : remplacer 0,150,0 par 3 valeurs entre 0 et 255 (RGB) (ligne 40) (ici nous avons choisi (34,117,68)

Ces multiples manipulations nous permettent de mieux appréhender les fonctionnalités d'Arduino et renforcent nos compétences en informatique.
Par la suite, nous avons utilisé le code "RGBWstrandtest" afin d'afficher différentes couleurs sur les LED et obtenir un résultat similaire à celui-ci :

À force de chercher des projets qui ressemblent au nôtre afin de nous baser sur l'un d'entre eux comme point de départ, nous nous sommes rendues compte que cela n'allait pas être facile. En effet, même si l'idée de contrôler des LEDs avec un capteur sonore a été visitée et revisitée, les projets que l'on trouve sur Internet utilise tous des composants différents des nôtres. Il est très certainement possible de créer son propre programme à partir de tous les projets proposés mais notre niveau et le temps qui nous était donné ne nous permettaient pas de réaliser cela. Ainsi, nous ne savions pas de quel point de départ partir afin de lancer notre projet.
Néanmoins, voici une tentative de faire réagir les LEDs aux données recueillies par le capteur de son :
#include "Adafruit_NeoPixel.h"
#ifdef __AVR__
 #include <avr/power.h>
#endif

#define PIN 6
#define NUMPIXELS 10
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(10, 6, NEO_GRB + NEO_KHZ800);
int loudness;

void setup()
{
 pixels.setBrightness(100);
 pixels.begin(); 
 pixels.show();
 Serial.begin(9600);
}

void loop()
{
 loudness = analogRead(0);
 Serial.println(loudness);
 delay(200);
 for (int i = 0; i < NUMPIXELS; i++) {
 pixels.setPixelColor(i, pixels.Color(0, 150, 0));
 pixels.show(); // This sends the updated pixel color to the hardware.
 delay(500); // Delay for a period of time (in milliseconds).
 }
}

Séances 6 à 9 : Le sonomètre portatif
Nous nous sommes rendues compte que notre projet de base, qui était de faire réagir des LEDs à du son, nous paraîssait au-delà de nos capacités. Nous avons donc décidé de partir sur un projet plus simple, en restant dans le thème de l'intensité sonore.
Notre projet est donc de réaliser un sonomètre portatif destiné aux étudiants qui ont tendance à passer beaucoup de temps dans les bars, boîtes de nuit, concerts, etc...
Programmation
Matériel :

M5Stack Core
module PLUS
capteur de son

Le module PLUS permet de connecter des capteurs qui se branchent en analogie ou en numérique. Cela correspond au port noir (GPIO ou port B).
La toute première étape est de réussir à afficher les données recueillies par le capteur de son sur le M5Stack. Nous nous sommes donc servies d'un code permettant d'afficher un spectre audio trouvé sur le site Hackster.io. Il a fallu modifier la valeur de "micpin" (ligne 28) de 34 à 36 pour que les données soient lues. Le code utilisé est le suivant :
/* ESP8266/32 Audio Spectrum Analyser on an SSD1306/SH1106 Display
 * The MIT License (MIT) Copyright (c) 2017 by David Bird. 
 * The formulation and display of an AUdio Spectrum using an ESp8266 or ESP32 and SSD1306 or SH1106 OLED Display using a Fast Fourier Transform
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files 
 * (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, 
 * publish, distribute, but not to use it commercially for profit making or to sub-license and/or to sell copies of the Software or to 
 * permit persons to whom the Software is furnished to do so, subject to the following conditions: 
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
 * See more at http://dsbird.org.uk 
*/
// https://github.com/tobozo/ESP32-8-Octave-Audio-Spectrum-Display/tree/wrover-kit
// https://github.com/G6EJD/ESP32-8266-Audio-Spectrum-Display
// https://github.com/kosme/arduinoFFT
 
 
#include "arduinoFFT.h" // Standard Arduino FFT library 
arduinoFFT FFT = arduinoFFT();
#include <M5Stack.h>
#define SAMPLES 512 // Must be a power of 2
#define SAMPLING_FREQUENCY 40000 
// Hz, must be 40000 or less due to ADC conversion time.
// Determines maximum frequency that can be analysed by the FFT Fmax=sampleF/2.

int micpin = 36; //change this to 36 if you are using the fc-04
 
struct eqBand {
 const char *freqname;
 uint16_t amplitude;
 int peak;
 int lastpeak;
 uint16_t lastval;
 unsigned long lastmeasured;
};
 
eqBand audiospectrum[8] = {
 //Adjust the amplitude values to fit your microphone
 { "125Hz", 500, 0, 0, 0, 0},
 { "250Hz", 200, 0, 0, 0, 0},
 { "500Hz", 200, 0, 0, 0, 0},
 { "1KHz", 200, 0, 0, 0, 0},
 { "2KHz", 200, 0, 0, 0, 0},
 { "4KHz", 100, 0, 0, 0, 0},
 { "8KHz", 100, 0, 0, 0, 0},
 { "16KHz", 50, 0, 0, 0, 0}
};
 
unsigned int sampling_period_us;
unsigned long microseconds;
double vReal[SAMPLES];
double vImag[SAMPLES];
unsigned long newTime, oldTime;
uint16_t tft_width = 320; // ILI9341_TFTWIDTH;
uint16_t tft_height = 240; // ILI9341_TFTHEIGHT;
uint8_t bands = 8;
uint8_t bands_width = floor( tft_width / bands );
uint8_t bands_pad = bands_width - 10;
uint16_t colormap[255]; // color palette for the band meter (pre-fill in setup)
 
void setup() {
 M5.begin();
 dacWrite(25, 0); // Speaker OFF
 M5.Lcd.fillScreen(TFT_BLACK);
 M5.Lcd.setTextColor(YELLOW, BLACK);
 M5.Lcd.setTextSize(1);
 M5.Lcd.setRotation(1);
 sampling_period_us = round(1000000 * (1.0 / SAMPLING_FREQUENCY));
 delay(2000);
 for(uint8_t i=0;i<tft_height;i++) {
 colormap[i] = M5.Lcd.color565(tft_height-i*.5, i*1.1, 0);
 }
 for (byte band = 0; band <= 7; band++) {
 M5.Lcd.setCursor(bands_width*band + 2, 0);
 M5.Lcd.print(audiospectrum[band].freqname);
 }
}
 
void loop() {
 for (int i = 0; i < SAMPLES; i++) {
 newTime = micros()-oldTime;
 oldTime = newTime;
 vReal[i] = analogRead(micpin); // A conversion takes about 1uS on an ESP32
 vImag[i] = 0;
 while (micros() < (newTime + sampling_period_us)) { 
 // do nothing to wait
 }
 }
 FFT.Windowing(vReal, SAMPLES, FFT_WIN_TYP_HAMMING, FFT_FORWARD);
 FFT.Compute(vReal, vImag, SAMPLES, FFT_FORWARD);
 FFT.ComplexToMagnitude(vReal, vImag, SAMPLES);
 
 for (int i = 2; i < (SAMPLES/2); i++){ 
 // Don't use sample 0 and only first SAMPLES/2 are usable. 
 // Each array eleement represents a frequency and its value the amplitude.
 if (vReal[i] > 1500) { // Add a crude noise filter, 10 x amplitude or more
 byte bandNum = getBand(i);
 if(bandNum!=8) {
 displayBand(bandNum, (int)vReal[i]/audiospectrum[bandNum].amplitude);
 }
 }
 }
 
 long vnow = millis();
 for (byte band = 0; band <= 7; band++) {
 // auto decay every 50ms on low activity bands
 if(vnow - audiospectrum[band].lastmeasured > 50) {
 displayBand(band, audiospectrum[band].lastval>4 ? audiospectrum[band].lastval-4 : 0);
 }
 if (audiospectrum[band].peak > 0) {
 audiospectrum[band].peak -= 2;
 if(audiospectrum[band].peak<=0) {
 audiospectrum[band].peak = 0;
 }
 }
 // only draw if peak changed
 if(audiospectrum[band].lastpeak != audiospectrum[band].peak) {
 // delete last peak
 M5.Lcd.drawFastHLine(bands_width*band,tft_height-audiospectrum[band].lastpeak,bands_pad,BLACK);
 audiospectrum[band].lastpeak = audiospectrum[band].peak;
 M5.Lcd.drawFastHLine(bands_width*band, tft_height-audiospectrum[band].peak,
 bands_pad, colormap[tft_height-audiospectrum[band].peak]);
 }
 } 
}
 
void displayBand(int band, int dsize){
 uint16_t hpos = bands_width*band;
 int dmax = 200;
 if(dsize>tft_height-10) {
 dsize = tft_height-10; // leave some hspace for text
 }
 if(dsize < audiospectrum[band].lastval) {
 // lower value, delete some lines
 M5.Lcd.fillRect(hpos, tft_height-audiospectrum[band].lastval,
 bands_pad, audiospectrum[band].lastval - dsize, BLACK);
 }
 if (dsize > dmax) dsize = dmax;
 for (int s = 0; s <= dsize; s=s+4){
 M5.Lcd.drawFastHLine(hpos, tft_height-s, bands_pad, colormap[tft_height-s]);
 }
 if (dsize > audiospectrum[band].peak) {
 audiospectrum[band].peak = dsize;
 }
 audiospectrum[band].lastval = dsize;
 audiospectrum[band].lastmeasured = millis();
}
 
byte getBand(int i) {
 if (i<=2 ) return 0; // 125Hz
 if (i >3 && i<=5 ) return 1; // 250Hz
 if (i >5 && i<=7 ) return 2; // 500Hz
 if (i >7 && i<=15 ) return 3; // 1000Hz
 if (i >15 && i<=30 ) return 4; // 2000Hz
 if (i >30 && i<=53 ) return 5; // 4000Hz
 if (i >53 && i<=200 ) return 6; // 8000Hz
 if (i >200 ) return 7; // 16000Hz
 return 8;
}
Ce programme permet donc de visualiser un spectre audio en fonction de la fréquence, or nous cherchons à visualiser l'intensité sonore. Même si nous n'avons pas utilisé ce programme par la suite, il nous a permis de comprendre comment définir le capteur dans Arduino (pin 36).
L'étape suivante est de configurer plusieurs réactions du M5Stack en fonction des données sonores. Le but est d'afficher différents messages de prévention pour informer l'utilisateur de son exposition au bruit.
Le code suivant permet d'afficher le message "attention" lorsque la valeur récoltée par le capteur est supérieure à 1000. Cette valeur est choisie arbitrairement pour l'instant.Ce programme suivant est construit à partir du code de test du capteur de son, ainsi que de quelques recherches qui nous ont permis d'inclure une condition "if". La valeur de la condition choisie est ici totalement arbitraire vu qu'on cherche uniquement à ce que le programme marche.
#include <M5Stack.h>
const int sensor = 36;

void setup()
{
 Serial.begin(115200);
 M5.begin();
 M5.Power.begin(); 
}

void loop()
{

 long sum = 0;
 for(int i=0; i<32; i++)
 {
 sum += analogRead(sensor); // permet de lire la valeur relevée par capteur
 sum >>= 2; // divise les valeurs par un certain facteur pour ne pas avoir de trop grandes valeurs 
 }
 Serial.println(sum); // écrit la valeur dans le plotter
 
 if (sum > 1000)
 {
 M5.Lcd.clear();
 M5.Lcd.print("attention");
 }

 delay(10);

}
Le but de notre objet est d'afficher différents messages de prévention en fonction de l'intensité sonore. Il faut donc imposer plusieurs conditions.Les niveaux d'intensité sonore sont indiqués en décibels et correspondent à des temps d'exposition hebdomadaires. Dans une boîte de nuit, l'intensité sonore varie entre 85 et 115 dB. Voici les messages affichés par le M5Stack en fonction de l'intensité sonore :

96 dB (5h d'exposition) : "Tu peux encore chiller pendant 5h"
103 dB (1h) : "Plus qu'une heure avant l'extinction des feux"
105 dB (10 min) : "Le temps d'une petite clope et au revoir"
115 dB (5 min) : "Prends tes affaires et sors ;)"

Pour imposer différentes conditions au M5Stack, il suffit de reprendre le programme ci-dessus et d'y ajouter de nouveaux opérateurs "if".
#include <M5Stack.h>
#include "Free_Fonts.h" 
const int sensor = 36;

void setup()
{
 Serial.begin(115200);
 M5.begin();
 M5.Power.begin();
}

void loop()
{
 while(1)
 {
 long sum = 0;
 for(int i=0; i<32; i++)
 {
 sum += analogRead(sensor); // permet de lire la valeur relevée par le capteur
 sum >>= 2; // divise la valeur par un certain facteur pour ne pas avoir des valeurs trop grandes
 }
 Serial.println(sum); // écrit la valeur dans le plotter

 if (sum < 100) //en dessous de 100 dB
 {
 M5.Lcd.clear();
 M5.Lcd.print("Tu peux encore chiller pendant 5h");
 delay(3000);
 }

 if (sum >= 100 && sum < 500) //entre 100 et 105 dB
 {
 M5.Lcd.clear();
 M5.Lcd.print("Plus qu'une heure avant l'extinction des feux");
 delay(3000);
 }

 if (sum >= 500 && sum < 1000) //entre 105 et 115 dB
 {
 M5.Lcd.clear();
 M5.Lcd.print("Le temps d'une petite clope");
 delay(3000);
 }

 
 if (sum >= 1000) //au dessus de 115 dB
 {
 M5.Lcd.clear();
 M5.Lcd.print("Prends tes affaires et sors ;)");
 delay(3000);
 }

 delay(10);
 }
 
}
Ici, les valeurs des conditions "if" ont encore une fois été choisies arbitrairement. Pour que l'objet soit réellement fonctionnel, il aurait fallu déterminer quelle plage de valeurs lues sur l'ordinateur correspond à quelle intensité sonore. On aurait pu utiliser une source de son de référence, dont on connaît l'intensité sonore, afin de "calibrer" notre capteur. Par souci de temps, nous n'avons pas pu réaliser cela.
Il faut maintenant s'occuper de la mise en forme du message affiché. Nous avons décidé de changer la couleur de l'écran en fonction de la dangerosité du niveau sonore. Nous avons aussi changer la police ainsi que la taille de la police. Toutes les modifications liées à la mise en forme sont inspirées des programmes que l'on peut trouver dans la bibliothèque du M5Stack, comme "Free Fonts" ou "Display".

Voici le programme final que nous avons utilisé :
#include <M5Stack.h>
#include "Free_Fonts.h" 
const int sensor = 36;

void setup()
{
 Serial.begin(115200);
 M5.begin();
 M5.Power.begin(); 
 M5.Lcd.setBrightness(100);
}

void loop()
{
 while(1)
 {
 long sum = 0;
 for(int i=0; i<32; i++)
 {
 sum += analogRead(sensor);
 sum >>= 2;
 }
 Serial.println(sum);

 if (sum < 100) //en dessous de 100 dB
 {
 M5.Lcd.clear();
 //uint16_t colorvalue = 0;
 //colorvalue = color565(0, 153, 0);
 M5.Lcd.fillScreen(GREEN); //colorvalue(0,153,0)
 M5.Lcd.drawRect(20, 20, 280, 200, WHITE); //cadre
 M5.Lcd.setTextColor(TFT_WHITE); //couleur du texte
 M5.Lcd.setTextSize(2);
 M5.Lcd.drawString("Tu peux encore chiller", 70, 108, 2);
 M5.Lcd.drawString("pendant 5h", 94, 132, 2);
 delay(3000);
 }

 if (sum >= 100 && sum < 500) //entre 100 et 105 dB
 {
 M5.Lcd.clear();
 M5.Lcd.fillScreen(YELLOW); //color565(255,213,0)
 M5.Lcd.drawRect(20, 20, 280, 200, BLACK); //cadre
 M5.Lcd.setTextColor(TFT_BLACK); //couleur du texte
 M5.Lcd.setTextSize(2);
 M5.Lcd.drawString("Plus qu'une heure avant", 70, 110, 2);
 M5.Lcd.drawString("l'extinction des feux", 90, 130, 2);
 delay(3000);
 }

 if (sum >= 500 && sum < 1000) //entre 105 et 115
 {
 M5.Lcd.clear();
 M5.Lcd.fillScreen(ORANGE); //color565(255,162,0)
 M5.Lcd.drawRect(20, 20, 280, 200, WHITE); //cadre
 M5.Lcd.setTextColor(TFT_WHITE); //couleur du texte
 M5.Lcd.setTextSize(2);
 M5.Lcd.drawString("Le temps d'une petite clope", 160, 112, 2);
 M5.Lcd.drawString("et au revoir", 160, 128, 2);
 delay(3000);
 }

 
 if (sum >= 1000) //au dessus de 115 dB
 {
 M5.Speaker.tone(1000, 500);
 M5.Lcd.clear();
 M5.Lcd.fillScreen(RED);
 M5.Lcd.drawRect(20, 20, 280, 200, WHITE); //cadre
 M5.Lcd.setTextDatum(MC_DATUM); //texte au centre
 M5.Lcd.setTextColor(TFT_WHITE); //couleur du texte
 M5.Lcd.setTextSize(2);
 M5.Lcd.drawString("Prends tes affaires et sors ;)", 160, 120, 2);
 M5.Speaker.end();
 delay(3000);
 }

 delay(10);
 }
 
}

Modélisation 3D
Shirel s'est chargée de concevoir et dessiner le packaging de notre objet. Elle a mesuré toutes les longueurs sur un M5stack de référence et les a reportées. On a donc choisi de créer un boîtier imprimé grâce a une imprimante 3D. Le choix d'une impression 3D s'est imposé de lui même. L'objet semble plus design, plus adapté à des jeunes. En découpe laser, il semblerait plus rustique (ce qui n'est pas forcément mauvais, mais ce n'est pas le but recherché).

On ferait une sorte d'ouverture permettant de laisser visible l'écran du M5 afin d'afficher les messages d'alerte.

Lily a commencé à modéliser sur FreeCAD la boîte qui servira à contenir le M5stack et le capteur.
Donc dans un premier temps, j'ai simplement créé un nouveau sketch dans la partie Part design. J'ai appliqué à ce sketch différentes contraintes de longueur et de symétrie pour qu'il soit dans les proportions que nous souhaitions. Par la suite, j'ai entré une protrusion afin d'obtenir une rectangle en 3D. Afin de créer une boite, il a fallu utiliser l'option "générer une coque solide" en sélectionnant la surface du dessus. Évidemment on modifie l'épaisseur de la protrusion afin que le boîte corresponde à nos mesures.

Par la suite, il a été question de dessiner le profil de l'ergo. Pour se faire, il faut créer un nouveau sketch en sélectionnant le plan XZ pour avoir la face souhaitée de profil. On fait donc "créer une arrête liée" afin d'avoir un point fixé au centre de l'arrête de la boite. Puis on peut tracer notre ergo en poly ligne. Il suffit simplement d'effectuer un triangle rectangle, auquel encore une fois, on applique des contraintes de longueur. Afin de mieux voir les arêtes et mieux me repérer, je suis passée en représentation filaire.

À partir de ce sketch, on va donc à nouveau créer une protrusion symétrique au plan, c'est-à-dire centrée sur l'arête. Par ailleurs, il est toujours important de centrer les choses par rapport aux axes de coordonnées, le wiki du fablab le conseil notamment.

Par la suite, pour me faciliter la tâche, j'ai simplement "créé une fonction de symétrie" afin de dupliquer mon ergo de l'autre côté.

Pour ce qui est du couvercle, j'avais préalablement dupliqué le fond de ma boîte pour éviter de refaire un rectangle, puis une protrusion etc... J'ai donc simplement modifié les dimensions en changeant les contraintes de longueur et largeur. En effet, afin que le fond et le couvercle de la boîte se clipsent entre eux à la fin, il faut que mon couvercle soit légèrement plus grand que le fond. J'ai donc laissé 0,5 mm de chaque côté afin d'avoir de la marge.

Afin de créer l'ergo du couvercle, j'ai suivi exactement les mêmes étapes que précédemment en créant un nouveau sketch, créer une arête liée, faire un triangle rectangle en poly ligne etc... La seule différence est, qu'afin que les deux parties de la boîte se clipsent, il est nécessaire que l'ergo du couvercle soit dirigé vers l'intérieur au lieu de l'extérieur. Donc au lieu de créer une protrusion, je crée une cavité. De plus, ses dimensions doivent être légèrement plus grandes (0,5mm de plus) afin d'avoir de la marge.

Pareil que pour le fond, je crée une fonction de symétrie pour avoir cet ergo des deux côtés.

Voici donc le rendu final de la boîte.

Afin de ne pas avoir beaucoup de support lors de l'impression, j'ai superposé les deux parties sur le même plan.

J'ai donc pu passer à l'impression 3D en enregistrant mon fichier dans le modèle qui convient pour FreeCAD. Une première impression a été faite mais malheureusement, on a eu un problème avec la machine.

L'impression finale a prit 6 heures au total et on a pu obtenir un rendu convaincant. Malheureusement, je pense que je n'avais pas pris assez de marge au niveau des dimensions du couvercle car la boîte avait du mal à se fermer, notamment avec le M5Stack dedans.

On a subit un autre échec quant à la volonté de creuser un trou dans le couvercle pour que l'on puisse voir l'écran du M5Stack à travers la boîte. L'application FreeCAD ne me permet pas d'appliquer une contrainte de longueur entre le haut de la boite et le haut de mon rectangle. Je n'ai donc pas réussi à placer mon rectangle où je le souhaitais sur le couvercle. Cette idée a donc été abandonnée.

Fonctionnement de l'objet et possibles améliorations

Pour s'assurer de son bon fonctionnement, nous avons effectué différents tests sur notre objet. Nous avons essayé en parlant et en mettant de la musique à différents volumes. Les messages affichés par le M5Stack sont bien cohérents avec les tests effectués mais on remarque tout de même que l'objet ne semble parfois pas capter correctement les ondes sonores. Par exemple, même en collant un téléphone avec du son très fort au sonomètre, le message affiché reste celui où il n'y a pas de danger.De plus, notre sonomètre n'est pas très efficace car la réelle dangerosité du son est lorsque l'on reste exposé.e pendant une certaine durée. Or ici, le message de prévention s'affiche lorsque le capteur recueille une seule valeur supérieure à la limite à un instant t précis, et non sur une certaine durée. Il est possible de visualiser le message "Prends tes affaires et sors ;)" puis quelques secondes plus tard, "Plus qu'une heure avant l'extinction des feux", ce qui n'a aucun sens pour l'utilisateur.
Pour régler ce problème, il faudrait ajouter à chaque condition "if" une condition de temps, où le message s'afficherait après que le capteur ait enregistré un certain nombre de valeurs dépassant la limite imposée à des intervalles de temps petits.

En ce qui concerne la boîte, il aurait aussi fallu fixer la capteur dedans et créer un trou pour que la paroi ne fasse pas office de barrière du son, qui viendrait diminuer et fausser les valeurs.

Conclusion générale du projet

Cette UE est construite de manière à ce que chaque séance soit indispensable pour la création de notre objet final. Nous avons réussi à faire en sorte que le sonomètre capte un son à une intensité sonore donnée. Cependant avec plus de temps, nous aurions pu trouver le bon code, le code qui permettrait par exemple d'alerter au 110 dB exactement atteints.

De plus, nous pouvions également améliorer toute la partie modélisation. En outre, notre boîte ne se ferme pas correctement. Si on continuait l'UE, on recommencerait la modélisation avec plus de marge dans les impressions.

Finalement, le choix d'une impression 3D, ne fut pas très judicieux. Si on avait réalisé la boîte à la découpe laser, la fabrication aurait été plus rapide. Des ajustements seraient encore possibles, si nous détections des erreurs, bien que le design recherché est au rendez- vous.

Rendu final
Messages

Boîte

Séance 10 : Présentation des projets
Lors de cette séance, nous avons assisté à la présentation des projets de chaque groupe.Voici un lien vers le support de notre présentation : projet fablab - sonomètre portatif

Projets personnels

Maïlys Hermann--Boyer
Réalisation d’une étoile à l’imprimante 3D & de jaeminbun à la découpe-laser
page de documentation : Étoile & jaeminbun

Shirel Fellous

2D et 3D Shirel

Lily-Rose Gavanon
Modélisations

King Dong : Les Rois de la Larme (Anciennement de la Sonette)

Membre du groupe: BREZOVSEK Kylian ; BERTOLETTI Alex ; BRIENDO Alex ; CAMUS Paul

Nous sommes des étudiants en première année de CMI. Dans le cadre de notre UE FABLAB (LU1SXPFL) nous avons pour objectif de concevoir un projet en groupe de 4 avec comme seule obligation l’utilisation d’au moins un capteur environnemental. Cette UE est divisée en 10 séances, à l’issue desquelles nous devrons réaliser une présentation de notre projet. Pour plus d’information, nous vous renvoyons sur cette page de Description de l’UE.

Séance 1 : Introduction au FabLab
Séance 1 : Nous avons découvert les locaux du FabLab et ses origines ainsi que l'état d'esprit de partage mis en place par son créateur Neil Gershenfeld. Nous avons ensuite commencé à réfléchir à notre idée de projet sur le thème des capteurs. Nous nous orientons pour l'instant vers un appareil qui serait utile dans le cadre de la pratique de la plongée sous-marine. Il s'agit d'un boîtier waterproof, que nous ferions le plus petit possible, contenant des capteurs de pression, de température et un GPS si nous arrivons à bien optimiser l'espace.

Séance 2 : Découverte de l'Arduino
Séance 2: La séance a commencé par un historique de l'électronique. De l'électromagnétisme à la micro-électronique actuelle, le monde de l'électronique s'est vu transformé par les physiciens au fil du temps. Nous avons été introduits à la carte Arduino, qui apporte une approche plus simple au prototypage que les circuits gravés. Au cours de travaux pratiques, nous avons découvert le langage Arduino, notamment les fonctions setup pour l'initialisation et loop pour faire une boucle. Aussi, nous savons maintenant où trouver des bibliothèques spécifiques et les importer afin de réaliser des tâches.

Afin de nous familiariser avec la carte Arduino, nous avons essayer d’y brancher plusieurs composants avec des branchements groves. Ces branchements sont des plus robustes que les câbles Dupont initialement utilisés et empêchent la mise en court circuit de la carte et ainsi endommager celle-ci. Dans un premier temps, nous y avons branché un capteur de température et d’humidité (comme l’image 1). Pour en extraire les données, il faut tout d’abord importer une bibliothèque qui va permettre de comprendre le code qui nous et ainsi d’afficher les données obtenues par le capteur sur la console.

Ensuite, nous y avons branché un écran LCD (image 2) et avons répété le protocole précédent. Toutefois, la bibliothèque disponible sur GitHub n’était pas fonctionnelle.

Séance 3 : Modélisation 2D et 3D
Séance 3 : Lors de cette troisième séance, nous avons découvert les différentes manières de modéliser un objet aussi bien en deux qu'en trois dimensions afin de pouvoir ensuite le faire confectionner par une machine (graveur laser et imprimante 3D).
Afin de modéliser en deux dimensions, nous avons utilisé le logiciel de dessin vectoriel Inkscape permettant de générer des fichiers SVG exploitables directement par les graveurs laser. Conventionnellement, on dessine en rouge les contours que nous souhaitons voir découpés et en noir ceux que nous souhaitons voir gravés, le tout toujours avec des traits d'un pixel d'épaisseur.

Dans le but de modéliser des objets en 3 dimensions, nous avons utilisé deux logiciels :

OpenSCAD qui nous permet de modéliser en utilisant du code de la forme
translate([0, 50, 0] cylinder(h = 50, r =100));

et pour lequel il existe une "cheat sheet"
FreeCAD, dont on utilisera surtout le workbench "Part"

Il est important de noter qu'il existe des banques de modèles 2D et 3D tels que Thingiverse (3D)
Nous avons également vu en fin de séance comment opérer les machines que nous utiliserons lors de notre projet, notamment via le logiciel IdeaMaker pour les imprimantes 3D

Séance 4 : Prototypage du M5Stack
Séance 4 : Au cours de cette séance, nous avons approfondi nos compétences préalablement acquises en prototypage. Nous avons premièrement testé le programme "Hello World" obtenu sur GitHub et utilisé sur un M5Stack Core-ESP32.
Nous avons ensuite téléchargé l'ensemble des fichiers GitHub liés au M5Stack. Puis, nous avons paramétré un M5Stack afin qu'il affiche la température et le pression mesurée par un capteur SHT31.
#include <M5Stack.h>
#include <Arduino.h>
#include <Wire.h>
#include "SHT31.h"
#include <Wire.h>
#include "rgb_lcd.h"
SHT31 sht31 = SHT31();
void setup() {
 M5.begin(); 
 M5.Power.begin(); 

 sht31.begin();
 
 M5.Lcd.print("Affichage pression et température"); 
}

void loop() {
 float temp = sht31.getTemperature();
 float hum = sht31.getHumidity();
 M5.lcd.print("Temp = "); 
 M5.lcd.print(temp);
 M5.lcd.println(" C"); //The unit for Celsius because original arduino don't support speical symbols
 M5.lcd.print("Hum = "); 
 M5.lcd.print(hum);
 M5.lcd.println("%"); 
 M5.lcd.println();
 delay(1000);
 
 M5.lcd.setCursor(0, 0); 
 M5.lcd.print("Temp = "); 
 M5.lcd.print(sht31.getTemperature());
 M5.lcd.setCursor(0, 1);
 M5.lcd.print("Humidity = "); 

 // print the number of seconds since reset:
 M5.lcd.print(sht31.getHumidity());
 
 delay(2000);

}
Nous avons ensuite modifié ce code afin d'afficher les données avec une police différente (plus grande et jaune) grâce au pack "Free Font" obtenu sur GitHub :
#include <M5Stack.h>
#include <Arduino.h>
#include <Wire.h>
#include "SHT31.h"
#include <Wire.h>
#include "rgb_lcd.h"
#include <M5Stack.h>
#include "Free_Fonts.h"
SHT31 sht31 = SHT31();

void setup() {
 M5.begin(); 
 M5.Power.begin(); 
 sht31.begin();
 
}

void loop() {
 M5.lcd.clear();
 int xpos = 0;
 int ypos = 40; 
 M5.Lcd.setFreeFont(FSB9);
 M5.Lcd.println(); 
 M5.Lcd.setTextColor(TFT_YELLOW);
 M5.Lcd.setCursor(xpos, ypos);
 float temp = sht31.getTemperature();
 float hum = sht31.getHumidity();
 M5.lcd.print("Temp = "); 
 M5.lcd.print(temp);
 M5.lcd.println(" C"); //The unit for Celsius because original arduino don't support speical symbols
 M5.lcd.print("Hum = "); 
 M5.lcd.print(hum);
 M5.lcd.println("%"); 
 M5.lcd.println();
 delay(500);
 
 M5.lcd.setCursor(0, 0); 
 M5.lcd.print("Temp = "); 
 M5.lcd.print(sht31.getTemperature());
 M5.lcd.setCursor(0, 1);
 M5.lcd.print("Humidity = "); 
 delay(1000);
}
Le résultat obtenu est le suivant :

Lors de la suite de la séance, nous avons chacun entreprit la modélisation de deux objets : un en 2 dimensions et un autre en 3.

Séance 4 bis : Petits projets : Découverte impression 3D et découpe laser
Projet avec graveuse/découpeuse laser :
Nom : BREZOVSEK Kylian : Projet carte à jouer e... | Wiki FablabSU (sorbonne-universite.fr)
Nom : BRIENDO Alex : https://wiki.fablab.sorbonne-universite.fr/BookStack/books/petits-projets/page/chapeau-de-luffy-le-pirate-et-cercle-de-transmutation

Nom : CAMUS Paul
J’ai eu l’idée de faire graver cette citation du film Astérix et Obélix : Mission Cléopatre : « Vous savez, moi je ne crois pas qu'il y ait de bonne ou de mauvaise situation. Moi, si je devais résumer ma vie aujourd'hui avec vous, je dirais que c'est d'abord des rencontres. Des gens qui m'ont tendu la main, peut-être à un moment où je ne pouvais pas, où j'étais seul chez moi. Et c'est assez curieux de se dire que les hasards, les rencontres, forgent une destinée... Parce que quand on a le goût de la chose, quand on a le goût de la chose bien faite, le beau geste, parfois on ne trouve pas l'interlocuteur en face je dirais, le miroir qui vous aide à avancer. Alors ça n'est pas mon cas, comme je disais là, puisque moi au contraire, j'ai pu : et je dis merci à la vie, je lui dis merci, je chante la vie, je danse la vie... je ne suis qu'amour ! Et finalement, quand beaucoup de gens aujourd'hui me disent « Mais comment fais-tu pour avoir cette humanité ? », et bien je leur réponds très simplement, je leur dis que c'est ce goût de l'amour ce goût donc qui m'a poussé aujourd'hui à entreprendre une construction mécanique, mais demain qui sait ? Peut-être simplement à me mettre au service de la communauté, à faire le don, le don de soi... ».
J’ai ensuite décidé de donner au contreplaqué la forme d’un parchemin/papyrus afin de rappeler l’Égypte, lieu où le film se déroule.
Pour ce faire, j’ai utilisé le logiciel Inkscape qui permet de dessiner en 2D n’importe quel objet. Par convention, la découpeuse laser sait que lorsqu’un trait est rouge, il faut découper et lorsqu’il est noir, il faut graver. J’ai rencontré un seul véritable problème : assigner 2 couleurs différentes à un seul et même trait. Pour palier à ce problème, j’ai voulu trouver le moyen de sectionner mon trait en 2. Grâce à Stéphane du FABLAB, que je remercie, j’ai découvert la touche qui permet de séparer 2 noeuds d’une même ligne ; ensuite il fallait sélectionner tous les noeuds de l’objet que je voulais colorer d’une autre couleur puis les couper (CTRL+X) et les coller afin de recréer un objet à part entière. Le résultat finale est le suivant :

Enfin, afin de pourvoir utiliser la découpeuse, il faut enregistrer l’image de notre objet en SVG en obtenant ainsi :

Je suis ensuite passé à l’utilisation de la découpeuse laser. J’ai utilisé celle-ci :

Clara, que je remercie aussi, m’a aidé à paramétrer la découpeuse en déplaçant la pointe du laser mais aussi en réglant numériquement mon objet. Pour le support, j’ai utilisé une chute de contreplaqué en 6mm. J’ai donc adapté la taille de mon objet en fonction de la place disponible sur la chute. J’ai ensuite lancé l’impression qui a commencé par graver le texte puis a terminé en découpant le bois.

Le résultat est au dessus de mes attentes, la découpeuse est étonnement précise.

Nom: Alexandre Bertoletti
Dans un premier temps, j’ai eu l’idée de me créer une règle graduée de 10 cm avec une image de mon choix dessus.

J’ai utilisé Inkscape pour réaliser ce projet, me permettant de dessiner en 2D. La tâche la plus longue pour une règle était de la gradué de manière précise. Pour commencer, j’ai tracé un rectangle de 15x5 cm pour laisser une marge de 2,5 cm entre le bord et le premier et dernier trait. Puis, avec le système précis de mesures d’Inkscape j’ai pu tracer les graduation une par une en changeant manuellement la position de tel sorte qu’elle soient positionnées à 1 mm d’interval, en prenant soin de tracer ceux correspondant à 0,5 et 1 cm un peu plus long des graduations de 0,1 mm pour des soucis de lisibilité
.
Ensuite pour remplir et décorer cette règle j’ai utilisé le système de vectorisation d’une image dans Inkscape qui permet de passer d’une photo à une image vectorielle noir, lisible par une machine à découpe laser.

La machine a pu lire ma réalisation sans problème et mon objet a été découper et réalisé parfaitement.

Projet avec imprimante 3D :
Nom : BREZOVSEK Kylian : Projet impression 3D clé | Wiki FablabSU (sorbonne-universite.fr)
Nom : CAMUS Paul
J’ai eu l’idée de modéliser 2 pièces de Lego avec le logiciel Freecad afin de pouvoir les emboîter.

Dans un premier temps, j’ai procédé à la modélisation de ma pièce en utilisant l’outil « sketch » permettant de dessiner une forme en 2D et d’ensuite pouvoir lui donner une épaisseur. J’ai choisi de faire 2 pièces avec 8 tétons pour m’assurer qu’elles tiennent bien ensemble. Puis, grâce à l’outil cavité, j’ai pu modifier la forme de mon rectangle d’origine.

Les dimensions de ma piece sont les suivantes :

- Pavé : longueur = 31,8mm ; largeur = 15,8mm ; hauteur = 9,6mm
- 8 Tétons supérieurs : rayon = 1,2mm ; distance par rapport au bord du pavé  le plus proche = 4mm ; hauteur = 1,8mm
- Cavité principale : longueur = 30,6mm ; largeur = 14,6mm ; hauteur = 8,6mm
- 3 Tétons inférieurs : rayon = 3,255mm ; distance par rapport au bord du pavé  le plus proche = 6,8mm ; hauteur = 8,6mm
- Cavités des 3 tétons inférieurs : rayon = 2,4mm ; profondeur = 8,6mm

On obtient alors le rendu suivant :

Lien du modèle 3D sous FreeCAD : lego 3d.FCStd
Ensuite, il faut l’exporter en format STL afin que l’imprimante puisse lire le fichier. Je remercie l’étudiant en Master d’entreprenariat issu d’une licence intensive qui m’a très bien expliqué le fonctionnement du logiciel IdeaMaker. Sur le logiciel, on voyait qu’il était préférable d’imprimer les pièces à l’envers, c’est-à-dire en commençant par les 8 tétons supérieurs afin de limiter les supports et la dégradation des sommets des tétons.

Lien des fichiers finaux :
lego 3d-Body.idea
lego 3d-Body.data 
lego 3d.FCStd
Enfin, j’ai lancé l’impression de 1h33. Le résultat finale est le suivant :

Après coup, j’aurais dû augmenter le rayon des 8 tétons ou alors le rayon des cavités des 3 tétons car mes briques ne s’emboîtent pas dans tous les sens.

Nom: Alexandre Bertoletti 
Dans un premier temps, j’ai eu l’idée de me créer un verre miniature en voulant le rendre le plus esthétique possible.

J’ai utilisé Freecad pour réaliser ce projet, me permettant de réaliser aisément des objets en 3D. j’ai d’abord créé un cylindre qui serait la forme principale de mon verre avec une boule de même diamètre que j’ai unies avec l'outil fusion et ensuite creusé à l’aide d’une autre cylindre de diamètre inférieur avec l'outil cut.

À la base de cette forme, j’y ai ajouté 3 carrés qui se superposent les uns sur les autres mais avec une différence de rotation de 60 degrés avec lesquels j’ai fait la différence pour créer un dodécagone que j’ai incorporé à la structure composé du cylindre et de la boule en la soustrayant à celle-ci en utilisant l’outils cut comme précédemment.

Pour finir, j’ai utilisé l'outil chamfer pour faire les “finitions”, donner un peu d’esthétisme au verre et qu’il soit agréable à utiliser.

Séance 5 : Projet King Dong
Séance 5 : L'objectif de cette séance était de poser les fondations du projet que nous allons entreprendre lors de cette UE. Après de nombreuses recherches sur des sites tels que Hackaday, nous avons décidé de nous lancer dans la conception et la réalisation d'une sonnette. Celle-ci devra remplir le cahier des charges suivant:

Sonner lorsque l'on appuie sur son bouton
Se mettre à filmer lorsqu'un mouvement est détecté a proximité
Rentrer dans un pavé droit de taille 10*10*3 cm
Pouvoir être accrochée à un mur

Un autre objectif, qui semble cependant plus complexe et que l'on considère donc pour l'instant comme facultatif, serait de faire en sorte que la vidéo captée par la sonnette soit consultable sur un téléphone par exemple, idéalement vient un feed en direct.
Afin de réaliser ce projet, nous avons dressé une liste du matériel nécessaire (en dehors de ce qui est déjà disponible au FabLab) et des sites où leur achat est possible au plus petit prix :

ESP 32 Cam Module
Capteur PIR
Arduino Push Button
Arduino Speaker

https://wiki.seeedstudio.com/edge-impulse-vision-ai

Séance 6 : Tests des capteurs pour notre projet
Séance 6 : Durant cette séance, nous avons testé deux capteurs pouvant remplir la tâche de détecter un mouvement ou une présence. Dans un premier temps, nous avons testé un capteur à ultrason : Ultrasonic Distance Sensor permettant de déterminer la distance entre le capteur et un objet présent devant le capteur.. Le résultat a été plutôt satisfaisant, le seul défaut pouvant être qu'il ne capte que très peu sur les côtés. Pour tester ce capteur, nous avons utilisé ce code.
//Make sure to install

#include <M5Stack.h>
#include "Ultrasonic.h"

Ultrasonic ultrasonic(22);
void setup()
{
 M5.begin();
}
void loop()
{
	long RangeInInches;
	long RangeInCentimeters;

	RangeInCentimeters = ultrasonic.MeasureInCentimeters(); // two measurements should keep an interval
	M5.Lcd.setCursor(10, 0);
	M5.Lcd.print(RangeInCentimeters);//0~400cm
 //M5.Speaker.tone(RangeInCentimeters, 200);
	delay(250);
}
Ensuite, nous avons testé un capteur de mouvement : Mini PIR Motion Sensor. Nous avons eu du mal à le faire fonctionner mais nous avons finalement trouvé un code fonctionnel. Finalement, nous pensons utiliser le capteur de mouvement qui permet d'avoir un angle plus large. Voici le code utilisé pour le test.
#include <M5Stack.h>

void setup() {
 M5.begin();
 Serial.begin(115200);
 M5.Lcd.clear(BLACK);
 M5.Lcd.setTextColor(YELLOW);
 M5.Lcd.setTextSize(2);
 M5.Lcd.setTextSize(2);
 M5.Lcd.setCursor(80, 0);
 M5.Lcd.println("PIR example");
 Serial.println("PIR example: ");
 M5.Lcd.setCursor(65, 10);
 M5.Lcd.setTextColor(WHITE);
 pinMode(36, INPUT);
}

void loop() {
 M5.Lcd.setCursor(0,25); M5.Lcd.print("Status: ");
 M5.Lcd.setCursor(0,45); M5.Lcd.print("Value: ");
 
 M5.Lcd.fillRect(95,25,200,25,BLACK);
 M5.Lcd.fillRect(95,45,200,25,BLACK);
 
 if(digitalRead(36)==1){
 M5.Lcd.setCursor(95, 25);M5.Lcd.print("Sensing");
 M5.Lcd.setCursor(95, 45);M5.Lcd.print("1");
 Serial.println("PIR Status: Sensing");
 Serial.println(" value: 1");
 }
 else{
 M5.Lcd.setCursor(95, 25);M5.Lcd.print("Not Sensed");
 M5.Lcd.setCursor(95, 45);M5.Lcd.print("0");
 Serial.println("PIR Status: Not Sensed");
 Serial.println(" value: 0");
 }
 delay(500);
 M5.update();
}

Séance 7 : Programmation des capteurs
Séance 7 :
Dans cette séance, nous avons dessiné la boite de notre sonnette. Grâce au site MakerCase, nous avions juste à rentrer les dimensions de notre boite :
- Largeur : 10cm
- Longueur : 15cm
- Profondeur : 7cm

Nous avons aussi rajouté 3 trous qui permettront de faire passer la caméra, le bouton et le capteur de mouvement.

Ensuite, nous devons programmer une sonnerie qui se déclenchera dès lors que le bouton de la sonnette sera enclenché. Pour ce faire, nous avons dans un premier temps utiliser un haut parleur, le Arduino Speaker 1.1, et défini une sonnerie trouvé sur Hackster.io avec le code

#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978
#define REST 0
#define END -1

int melody[] = {
 NOTE_E5, NOTE_DS5, //1
 NOTE_E5, NOTE_DS5, NOTE_E5, NOTE_B4, NOTE_D5, NOTE_C5,
 NOTE_A4, NOTE_C4, NOTE_E4, NOTE_A4,
 NOTE_B4, NOTE_E4, NOTE_GS4, NOTE_B4,
 NOTE_C5, REST, NOTE_E4, NOTE_E5, NOTE_DS5,
 
 NOTE_E5, NOTE_DS5, NOTE_E5, NOTE_B4, NOTE_D5, NOTE_C5,
 NOTE_A4, NOTE_C4, NOTE_E4, NOTE_A4,
 NOTE_B4, NOTE_E4, NOTE_C5, NOTE_B4,
 NOTE_A4 , REST, END

};

// note durations: 8 = quarter note, 4 = 8th note, etc.
int noteDurations[] = { //duration of the notes
4, 4,
4, 4, 4, 4, 4, 4,
4, 4, 4, 4,
4, 4, 4, 4,
4, 4 ,4, 4, 4,

4, 4, 4, 4, 4, 4,
4, 4, 4, 4,
4, 4, 4, 4,
1, 2, 20

};

int speed=90; //higher value, slower notes
void setup() {

Serial.begin(9600);
for (int thisNote = 0; melody[thisNote]!=-1; thisNote++) {

int noteDuration = speed*noteDurations[thisNote];
tone(3, melody[thisNote],noteDuration*.95);
Serial.println(melody[thisNote]);

delay(noteDuration);

noTone(3);
}
}

void loop() {
}

Séance 8 : Caméra AI Module Vision
Dans cette séance, nous avons essayé de programmer la caméra AI Module vision. Nous avons dans un premier temps dû souder un Xiao sur la caméra afin de pouvoir la relier à une carte Arduino ou un M5Stack. Pour ce faire, nous avons souder une barrette femelle longue sur la carte de la caméra et une barrette droite mâle longue sur le Xiao.

Une fois cela fait, nous sommes ensuite revenu sur la configuration de la caméra. Nous avons dû chercher sur de nombreux sites car cette caméra est relativement récente et la documentation sur celle-ci se fait extrêmement rare ou bien pour des applications très spécifiques. Que ce soit sur Seed Studio, ou EdgeImpulse, la documentation est faite à partir d’autres interfaces que l’Arduino ou le M5Stack comme le Raspberry nous rendant ainsi impossible l’exploitation de la Caméra AI Module Vision. Il semblait possible de faire fonctionner la caméra avec le XIAO, mais nous n'avons pas réussi à aboutir même en suivant rigoureusement les indications fournies. Notamment, la documentation parlait d'un logiciel nommé Bouffalo que nous n'arrivions pas à comprendre. Par ailleurs, nos capacités en informatique et en codage ne nous permettant pas de développer un code de A à Z,  nous avons décidé de mettre fin au projet King Dong.

Cette séance nous a montré que la documentation est vraiment quelque chose de fondamental, c’est pourquoi nous vous avons mis tous les liens que nous avons trouvés afin de rassembler le plus d’information possible pour les prochaines personnes qui utiliseront cette caméra.

Séance 9 : Projet Alarme Incendie : les Rois de la Larme
La décision de la séance dernière nous a obligé a changer de projet.  En effet, les multiples échecs liés à la caméra AI Module Vision nous ont mené à tout repenser depuis le départ afin de rebondir promptement sur un projet nouveau dont les fondations pourraient être bâties sur les ruines du regretté empire de la sonnette que nous avions pourtant corps et âme tenté de faire fructifier.
Tout le progrès fait jusqu'alors n'était donc pas perdu : il constituerait l'armature neuve d'un projet dont l'aboutissement technique n'aura d'égal que la splendeur.
Afin de repartir, nous nous sommes questionnés quant à ce qui était à notre disposition : un code permettant de jouer de la musique et un autre permettant de faire fonctionner un capteur de mouvement PIR. Nous avons de plus trouvé parmi les nombreux capteurs à notre disposition au FabLab un détecteur de flamme. Mis face à tous ces éléments, nous eûmes une révélation salvatrice commune : celle de réaliser une double alarme, à la fois à incendie et à intrusion.
Suite à cette illumination collective, nous cherchâmes à bride abattue un code permettant de faire fonctionner le Flame Sensor que nous avons su prestement et talentueusement allier au code pour le Capteur PIR (voir séance 6) et à celui pour la musique (séance 7) afin d'obtenir le code final pour notre alarme :

#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978
#define REST 0
#define END -1

#define PIR_MOTION_SENSOR 2

int melody[] = {
 NOTE_E5, NOTE_DS5, //1
 NOTE_E5, NOTE_DS5, NOTE_E5, NOTE_B4, NOTE_D5, NOTE_C5,
 NOTE_A4, NOTE_C4, NOTE_E4, NOTE_A4,
 NOTE_B4, NOTE_E4, NOTE_GS4, NOTE_B4,
 NOTE_C5, REST, NOTE_E4, NOTE_E5, NOTE_DS5,
 
 NOTE_E5, NOTE_DS5, NOTE_E5, NOTE_B4, NOTE_D5, NOTE_C5,
 NOTE_A4, NOTE_C4, NOTE_E4, NOTE_A4,
 NOTE_B4, NOTE_E4, NOTE_C5, NOTE_B4,
 NOTE_A4 , REST, END
};

// note durations: 8 = quarter note, 4 = 8th note, etc.
int noteDurations[] = { //duration of the notes
4, 4,
4, 4, 4, 4, 4, 4,
4, 4, 4, 4,
4, 4, 4, 4,
4, 4 ,4, 4, 4,

4, 4, 4, 4, 4, 4,
4, 4, 4, 4,
4, 4, 4, 4,
1, 2, 20
};

int melody2[] = {
 REST, NOTE_DS4,
 NOTE_E4, REST, NOTE_FS4, NOTE_G4, REST, NOTE_DS4,
 NOTE_E4, NOTE_FS4, NOTE_G4, NOTE_C5, NOTE_B4, NOTE_E4, NOTE_G4, NOTE_B4, 
 NOTE_AS4, NOTE_A4, NOTE_G4, NOTE_E4, NOTE_D4,
 NOTE_E4, REST, END };

int noteDurations2[] = { //duration of the notes
2, 2,
1, 2, 2, 1, 2, 2,
2, 2, 2, 2, 4, 2, 2, 2,
4 , 2, 2, 2, 4,
2, 2, 20

};

int speed=90;

// lowest and highest sensor readings:
const int sensorMin = 0; // sensor minimum
const int sensorMax = 1024; // sensor maximum

void setup() {
 pinMode(PIR_MOTION_SENSOR, INPUT);
 Serial.begin(9600); 
}
void loop() {
 // read the sensor on analog A0:
 int sensorReading = analogRead(A0);
 // map the sensor range (four options):
 // ex: 'long int map(long int, long int, long int, long int, long int)'
 int range = map(sensorReading, sensorMin, sensorMax, 0, 8);
 
 // range value:
 switch (range) {
 case 0: // A fire closer than 1.5 feet away.
 Serial.println("** Close Fire **");
 for (int thisNote = 0; melody[thisNote]!=-1; thisNote++) {
 int noteDuration = speed*noteDurations[thisNote];
 tone(3, melody[thisNote],noteDuration*.95);
 Serial.println(melody[thisNote]);
 delay(noteDuration);
 noTone(3);
}
 break;
 case 1: // No fire detected.
 Serial.println("No Fire");
 break;
 case 2: // No fire detected.
 Serial.println("No Fire");
 break;
 case 3: // No fire detected.
 Serial.println("No Fire");
 break;
 case 4: // No fire detected.
 Serial.println("No Fire");
 break;
 case 5: // No fire detected.
 Serial.println("No Fire");
 break;
 case 6: // No fire detected.
 Serial.println("No Fire");
 break;
 case 7: // No fire detected.
 Serial.println("No Fire");
 break;
 }
 delay(1); // delay between reads

 if(digitalRead(PIR_MOTION_SENSOR))//if it detects the moving people?
 for (int thisNote = 0; melody2[thisNote]!=-1; thisNote++) {
 int noteDuration2 = speed*noteDurations2[thisNote];
 tone(3, melody2[thisNote],noteDuration2*.95);
 Serial.println(melody2[thisNote]);
 delay(noteDuration2);
 noTone(3);}
 else
 Serial.println("Watching");

 delay(200);
}
Il est important de noter qu'en terme de branchements, il est nécessaire de brancher l'Arduino Speaker au port D3, le PIR Sensor au D2 et le Flame Sensor au A0.
Ce code nous permet alors de jouer la Lettre pour Élise de Beethoven en cas d'incendie et le cultissime générique de La Panthère Rose en cas d'intrusion. Ces deux musiques, provenant originalement d'un GitHub par nos soins sanctifié tant il nous a été utile, ont été longuement réadaptées de nos frêles mains note par note afin de fonctionner avec notre code et équipement.
Mais que serait le module Arduino sans sa batterie, lui procurant puissance et autonomie à toute épreuve?  Dans la salle d'électronique, nous trouvâmes un réceptacle qui, à première vue, ne payait pas de mine. Cependant, une fois couplé à une triplette de pile AAA et après un branchement minutieux au module Arduino, ce dispositif laissa éclater tout son potentiel et se montra tout à fait adéquat à la réalisation de notre ambitieux projet.

Suite à ce véritable travail d'horlogerie suisse, il ne nous restait plus qu'a confectionner le digne réceptacle qui accueillerait notre merveille technique.
Lors de la séance 6, nous avions établi les plans d’une boite capable d’accueillir le désormais caduc projet King Dong. En usant du même logiciel (MakerCase), nous avons designé un contenant assez noble pour accueillir cette innovation immodérément novatrice dans son domaine.Ces plans  à la fois complexes et puristes respectent les dimensions suivantes :
- Largeur : 14cm
- Longueur : 14cm
- Profondeur : 7cm

Sublimée par l’enseigne de notre marque et accompagné de son logo, le rendu est tel que :

Les capteurs nécessitant une exposition extérieure pour fonctionner, nous étions dans le besoin de créer 2 orifices. Après de nombreuses mesures, nous nous sommes arrêtés sur ce modèle :

Lors de l’assemblage final de notre prototype, Alexandre, un employé du FABLAB, gravait un QR code sur une plaque de PMMA. Nous vient alors l’idée de graver à notre tour un QR Code menant à la page Wiki de notre alarme. Pour ce faire, rien de plus simple, il suffit d'utilisé le magnifique logiciel qu'est Inkscape et d'ouvrir le menu puis de cliquer sur extensions, rendu, Code-barres et finalement QR code avant de rentrer dans la page qui s'ouvre le lien de notre parfaite documentation et le tour est joué.

Soudain, une terrible nouvelle vint s’abattre sur notre groupe. Le haut parleur décidait de faire des siennes. Après quelques rectifications, il retrouvait ses capacités. Toutefois, le vent de jeunesse qui l’animait n’était plus … le son qu’il dégageait n’était plus aussi puissant que celui d’antan. Nous vient alors l’idée de designer des trous sur une des nobles tranches de notre appareil afin de diminuer au maximum les pertes d’intensité sonore. Désormais vêtu de son illustre documentation ainsi que de splendide orifice, notre projet atteignait calmement son apogée.

Toute bonne chose ayant une fin, l’heure de l’étape finale fut venue. Assemblant à grands coups de colle à bois pour le réceptacle et de scotch pour les composants, notre appareil fut revêtit de ses plus divins ornements en un rien de temps. Une aventure venait de prendre fin mais une légende était créée …

Séance 10 : Présentation finale
Nous sommes dimanche après-midi, l’heure de notre soutenance arrive à grands pas. Soudain, une Visio-conférence est programmée à 15h précise. Ce n’est que 2h après que nous arrivâmes enfin à trouver un consensus. Notre projet étant, disons-le nous, relativement simpliste, il nous fallait tout miser sur notre dernière resource : l’humour. De cette décision en est ressorti ce diaporama.

Il est 9h, nous sommes lundi matin, un silence d’outre-tombe règne dans le Fablab. Les soutenances se font attendre mais notre assiduité aura raison de nous. Notre groupe se trouvant être l’unique groupe au complet, notre soutenance ouvre le bal. 20 minutes plus tard, des sourires se dessinent sur tous les visages. Notre mission est un franc succès. Les Rois de la Larme ont vaincu. Néanmoins, notre présentation est jugée, à juste titre, un peu trop bâtarde entre un pitch de start up et une présentation formelle et approfondie du sujet. En effet, il aurait été préférable de se concentrer uniquement sur l’humour pour présenter notre projet en survolant très rapidement les détails les plus importants et en se concentrant sur utilisation.

Groupe B3


Membre du groupe:

Clément BAILLY, Pierre BERNARDE, Leeloo BLEYNIE, Vitaly POPOFF

Séance 1 : introduction de l'UE
Séance 1 : introduction de l'UE 

Présentation globale :

M. Dupuis nous a montré les attendus de l'UE,, les projets à réaliser.
Nous réaliserons un projet scientifique en 10 séances, en se servant de la base de données du réseau FabLab et de son outillage disponible. Cette année, le projet portera sur le thème des capteurs météo

Cours sur l'histoire des FabLab

Un fab lab (contraction de l'anglais fabrication laboratory, « laboratoire de fabrication ») est un tiers-lieu de type makerspace cadré par le MIT et la FabFoundation en proposant un inventaire minimal permettant la création des principaux projets fab labs, un ensemble de logiciels et solutions libres et open-sources, les Fab Modules, et une charte de gouvernance, la Fab Charter
Ils sont créés en 1995 par Neil Gershenfeld, et sont considérés comme très pratiques pour la communauté scientifique.

Visite des locaux du FabLab : 

Nous disposons d'imprimantes 3D, de machines de découpe et de gravure, de fraiseuses, et d'un labo d'assemblage électronique pour construire la structure de l'objet technique à concevoir. 

Séance 2 : composants électroniques
Séance 2 : composants électroniques
Cours magistral de 3h sur :

les composants électroniques, le prototypage, les transistors, etc..
la carte Arduino. Il s'agit d'une carte connectable à la fois à un ordinateur et à différents modules (gazomètre, thermomètre, écran, haut-parleur, détecteur de CO2, etc).

Cette carte est très polyvalente, et son utilisation est relativement simple. Elle est plus simple et plus compacte dans un montage électronique par rapport aux fils Dupont (utilisables sur une breadboard). Elle peut être associée à différents modules, fournissant différentes informations comme la température, l'humidité de l'air, la pression, mais également des périphériques externes comme comme un haut-parleur, un buzzer, etc.

Le code sur arduino a une structure assez spécifique : il faut tout d'abord inclure les bibliothèques de code fonctionnant avec les modules utilisés (écran, capteur...) ainsi que les variables que nous voudrions utiliser après. Ensuite dans la fonction setup il faut mettre tout ce qui permet d'initialiser les composants et de les préparer au code principal ainsi que tous les codes qui sont utilisés qu'une seule fois. Pour finir il y a la fonction loop qui comme son nom l'indique permet de faire une "boucle" dans le code et donc de répéter périodiquement certaines actions.
Nous avons tout d'abord voulu tester l'appareil avec un capteur d'humidité. Ce module utilise l'extension I2C, nous l'avons donc connecté à ce port de la carte, que nous avons reliés à un ordinateur. Il faut ensuite télécharger la bibliothèque associée à ce module et prendre le code d'exemple en bas de page nous permettant de voir la température ainsi que l'humidité sur le moniteur série comme ceci :

Nous avons ensuite utilisé séparément un écran OLED et avons utilisé le fameux code "hello world" en bas de page pour voir comment il fonctionnait nous donnant ce résultat :

Pour finir nous avons combiné les deux codes afin d'afficher les valeurs de température et d'humidité du capteur sur l'écran OLED de la sorte :

Code lecture de l'humidité et de la température du SHT31 :
#include <Arduino.h>
#include <Wire.h>
#include "Adafruit_SHT31.h"

bool enableHeater = false;
uint8_t loopCnt = 0;

Adafruit_SHT31 sht31 = Adafruit_SHT31();

void setup() {

 Serial.begin(9600);

 while (!Serial)

   delay(10);   

 Serial.println("SHT31 test");

 if (! sht31.begin(0x44)) { 

   Serial.println("Couldn't find SHT31");

   while (1) delay(1);

 }

 Serial.print("Heater Enabled State: ");

 if (sht31.isHeaterEnabled())

   Serial.println("ENABLED");

 else

   Serial.println("DISABLED");
}

void loop() {

 float t = sht31.readTemperature();

 float h = sht31.readHumidity();

 if (! isnan(t)) { 

   Serial.print("Temp *C = "); Serial.print(t); Serial.print("\t\t");

 }else{

   Serial.println("Failed to read temperature");

 }

 if(! isnan(h)){

   Serial.print("Hum. % = "); Serial.println(h);

 }else{

   Serial.println("Failed to read humidity");

 }

 delay(1000);

 if (loopCnt >= 30) {

   enableHeater = !enableHeater;

   sht31.heater(enableHeater);

   Serial.print("Heater Enabled State: ");

   if (sht31.isHeaterEnabled())

     Serial.println("ENABLED");

   else

     Serial.println("DISABLED");

   loopCnt = 0;

 }

 loopCnt++;
}
Code "hello world" OLED :
#include <Wire.h>
#include <SeeedOLED.h>

void setup() {

   Wire.begin();

   SeeedOled.init();

   SeeedOled.clearDisplay();         

   SeeedOled.setNormalDisplay();     

   SeeedOled.setPageMode();         

   SeeedOled.setTextXY(0, 0);       

   SeeedOled.putString("Hello World!");
}
void loop() {
}
Code d'affichage des données du SHT31 sur l'écran OLED :
#include <Arduino.h>
#include <Wire.h>
#include "Adafruit_SHT31.h"
#include <SeeedOLED.h>

Adafruit_SHT31 sht31 = Adafruit_SHT31();

void setup() {

 Wire.begin();

 SeeedOled.init(); 

 SeeedOled.clearDisplay();         

 SeeedOled.setNormalDisplay();     

 SeeedOled.setPageMode();         

 sht31.begin(0x44);
}

void loop() {

 float t = sht31.readTemperature();

 float h = sht31.readHumidity();

 SeeedOled.clearDisplay();

 SeeedOled.setTextXY(0, 0);

 SeeedOled.putString("temp=");

 SeeedOled.putFloat(t);

 SeeedOled.putString("°C");

 SeeedOled.setTextXY(1, 0);

 SeeedOled.putString("hum=");

 SeeedOled.putFloat(h);

 SeeedOled.putString("%");

 delay(10000);
}

Séance 3 : logiciels de design
Séance 3 : logiciels de design
Lors de cette séance nous avons appris à utiliser le logiciel de dessin 2D Inkscape ainsi que les logiciels de modélisation 3D OpenSCAD et FreeCAD. Ces logiciels sont très pratiques car ils sont gratuits et opensource.

Inkscape :

Ce logiciel peut être utilisé pour faire du graphisme mais nous l'utilisons surtout pour faire de la découpe au laser ainsi que de la gravure sur bois (max 8mm d'épaisseur pour nos machines). Pour que la découpeuse laser fonctionne, il faut que le document soit en format SVG. Il faut aussi que les traits soient d'un pixel d'épaisseur de couleur rouge pour la découpe et noir pour la gravure.

Logiciels de 3D :

Ces logiciels permettent de réaliser des formes en 3D que l'on peut imprimer par la suite. Les machines utilisées au Fablab n'acceptent que des formats STL. Ces documents doivent ensuite être traités avec le logiciel Ideamaker nous permettant de programmer les conditions d'impression (taille du fil, remplissage, supports...). Sur FreeCAD il suffit de placer ses formes et de les déplacer à l'aide de la barre d'outils tandis que sur OpenSCAD il faut faire apparaitre les objets grâce à du code.

Nous avons donc pendant cette séance réalisé quelques modélisations afin de voir comment les manipuler. Nous avons fais ce dessin sur Inkscape :

Nous avons ensuite réalisé un cube de 50mm de diamètre avec à l'intérieur des trous faits à l'aide de trois cylindres de 20mm de rayon centrés au niveau du centre des faces. Voici ce que cela donne sur les deux logiciels de 3D :
Sur FreeCAD :

Sur OpenSCAD (code puis forme):
difference() {
 cube(50,center=true);
 translate([0,0,-30]) cylinder(h=60,r=20);
 rotate([90,0,0]) translate([0,0,-30]) cylinder(h=60,r=20);
 rotate([0,90,0]) translate([0,0,-30]) cylinder(h=60,r=20);
}

Séance 4 : approche de la M5stack
Séance 4 : approche de la M5stack

Nous avons étudié l'utilisation de la carte m5stack, et son logiciel.
Cette carte permet tout comme la carte Arduino, de connecter différents modules à un ordinateur, mais a beaucoup plus d'options (ordinateurs, boutons...).

Nous avons téléchargé les modules depuis M5stack GitHub, et essayé plusieurs programmes de base, comme "HelloWord", qui a fonctionné avec ce code

#include <M5Stack.h>
void setup() {
 M5.begin();
 M5.Power.begin();
 M5.Lcd.print("Hello World");
}
void loop() {
}

Nous avons ensuite essayé de connecter le module "capteur d'humidité" de la dernière fois avec la carte M5stack. Il fallait donc modifier le code qu'on avait pour l'adapter, ce que nous n'avons pas réussi.
Puis nous avons essayé le module "Tetris" (permettant normalement de jouer au jeu sur la carte M5stack) mais cela n'a pas marché.

Séance 5 : début du projet
Séance 5 : début du projet
Cette séance était la 1ère entièrement en autonomie, ou nous avons commencé à réfléchir au projet que nous allons réaliser.
Pour cela, M.Dupuis nous a conseillé 3 sites proposant des méthodes d'assemblage et de codes pour différents appareils:

hackster.io
instructables
hackaday

Ce sont des sites ouverts au public, des banques de données de passionnés qui partagent des montages d'appareils en tout genre.
Nous avons convenu de créer une station météo multifonction, avec haut parleur. Pour cela nous nous sommes basés sur un modèle m5stack de station déjà existante sur internet. On va donc d'abord la recréer avec le matériel disponible avant d'innover pour arriver au résultat souhaité.
Pour cela il nous faut :

une carte M5STACK (faisait également office d'écran)
un capteur de lumière
un capteur thermique
un capteur de pression

Pour finir, nous avons commencé à manipuler le code informatique relatif aux différents composants pour pouvoir tous les utiliser sur la carte M5stack.

Séance 6 : cahier des charges
Séance 6 : Cahier des charges
Lors de cette séance nous avons finaliser le cahier des charges de notre objet. Voici la les fonctionnalités que nous voulons qu'il est :
Il faut qu'il affiche :

la température
l'humidité
la luminosité
la pression
l'heure
la météo présente et de la journée qui arrive (si c'est faisable)

Ces données vont être affichées sur 4 écrans lcd et l'écran du M5. Pour les écrans lcd, nous voulons afficher une des 4 première données par écran soit en l'écrivant soit en faisant une graduation que nous graverions sur la boîte. Il suffirait d'allumer seulement une petite partie de l'écran quand la valeur et faible et inversement. L'heure et la météo seraient elles sur l'écran du M5. Pour recueillir la météo, nous avons trouver un site qui permet au M5 de recevoir les informations de la météo moins d'un centime par requête. Ceci est sûrement faisable car le m5 peut se connecter à internet. Il y a cependant un problème, il y a trop de composants pour le M5 et certains ont la même adresse donc c'est impossible de communiquer séparément avec eux. Nous voulons donc utiliser un multiplexeur permettant cela, le Grove - 8 Channel I2C Multiplexer/I2C Hub (TCA9548A).
Il faut aussi qu'on puisse sélectionner une de ces données et grâce à un bouton avoir la boîte qui dise un message lié à cette valeur. Par exemple dire quand il fait 20°C "ça va tu peux sortir en t-shirt". Pour faire ceci, nous avons pensé à utiliser le haut-parleur ainsi que les boutons du M5. Il suffirait d'appuyer sur les boutons de gauche et de droite pour changer de donnée et d'appuyer sur celui du centre pour que cela le dise. Pour permettre de visualiser la sélection, nous pensons à faire changer la couleur des écrans. Nous pouvons aussi utiliser une led par donnée qui s'allume quand cette dernière est sélectionnée.
Nous avons ensuite brièvement réfléchi au design de la boîte et avons décidé de faire une façade ressemblant à ceci :

Le trou en bas serait pour le M5, les autres rectangulaires pour les écrans et les ronds pour les leds.

Séance 7 : montage électronique
Séance 7 : montage électronique
Nous avons durant cette séance, fini la réalisation technique du dispositif :

Comme vous pouvez le voir nous avons abandonné les leds car c'était techniquement trop compliqué. Il nous aurait fallu en plus un deuxième multiplexeur et ça paraissait déjà assez compliqué avec les écrans.

Nous avons donc connecté la carte M5stack (en haut à droite) à un hub I2C (en bas à droite). Voici sa référence et une image de lui
Grove - 8 Channel I2C Multiplexer/I2C Hub (TCA9548A) https://wiki.seeedstudio.com/Grove-8-Channel-I2C-Multiplexer-I2C-Hub-TCA9548A/ . 

Vu que la majorité de nos modules sont dans ce format, c'est la manière la plus compacte à notre disposition que l'on peut utiliser pour réaliser ce projet. Nous y avons ajouté les composants suivants :

Capteur de lumière (light sensor v.1.2) + convertisseur analogique  https://wiki.seeedstudio.com/Grove-Light_Sensor/

Toute station météo doit être capable de capter et donner un indice de la lumière ambiante. Cependant, nous avons utilisé un hub I2C, et notre light sensor (à gauche) n'était pas compatible. Il a donc fallu ajouter un convertisseur analogique (à droite) capable de transformer le signal d'origine en format I2C.

Baromètre

Ecran affichant l'heure

Capteur d'humidité et thermomètre

4 écrans LCD https://wiki.seeedstudio.com/Grove-16x2_LCD_Series/

Ils vont servir à afficher les valeurs des 4 modules. Nous nous sommes demandés par quel moyen nous allions faire ça. Nous avons opté pour un système de graduation, avec l'échelle indiquée sous chaque écran, plutôt qu'un nombre directement affiché sur dessus.
Enfin, nous nous sommes penchés sur la structure du code informatique. Afficher les données sur les écrans est normalement pas trop compliqué sauf qu'il faut arriver à communiquer avec eux séparément. Pour cela il faudrait réussir à faire marcher le multiplexeur. La partie plus compliquée du code est l'utilisation des leds et le haut-parleur. La structure de son fonctionnement ressemblerait à quelque chose comme cela :
avec n le numéro de l'écran
récupérer les données
les afficher

si le bouton droit est pressé
	si n=5
 	ne rien faire
 sinon
 	n=n+1
 
si le bouton droit est pressé
	si n=5
 	ne rien faire
 sinon
 	n=n+1
 
si n=1
	mettre l'écran 1 en vert
 k = donnée affichée
sinon
	mettre l'écran 1 en blanc
 
copier ceci pour les 5 écrans

si le bouton central est pressé
	si n=1
 	lire la piste audio associée à la valeur k et la donnée
 
 copier ceci pour les 5 écrans

Séance 8 : problèmes et solutions
Séance 8 : problèmes et solutions
Durant cette séance, ayant de sérieux problèmes à faire fonctionner la carte M5stack et saisir le bon code informatique, je (Clément) me suis tourné vers un montage alternatif de station météo utilisant la carte arduino :
https://www.instructables.com/Weather-Station-With-Arduino-Station-M%C3%A9t%C3%A9o-Avec-Ar/
Ce montage est parfaitement documenté, simple à réaliser en comparaison de ce que nous avions entrepris. Il requiert :
1. Un écran LCD alphanumérique 16x2
2. Un capteur de température TMP36
3. Un haut-parleur de 8 Ohm
4. Un potentiomètre de 10 kilos Ohm
5. Deux résistance de 220 ohm
6. Beaucoup de fils
7.Une Breadboard ou platine d'expérimentation
8. Un Arduino (J'utilise un Uno)
Les instructions sont disponibles sur Instructables, via le lien envoyé.
J'ai réalisé une grosse partie du montage, mais manquant de certains composants, je n'ai pas pu finir.

Une fois le montage prêt, il faut ajouter le code suivant dans l'application Arduino :

https://content.instructables.com/F6A/V3BV/KM3GBVUI/F6AV3BVKM3GBVUI.ino
Pendant ce temps, Pierre et Vitaly ont essayés de résoudre les problèmes avec le multiplexeur. Il est sensé pouvoir communiquer avec plusieurs objets ayant la même adresse cependant, il faut bidouiller des choses pour y arriver. Une des solutions serait d'arriver à changer les bibliothèques des écrans pour changer définitivement leur adresse. Cependant, malgré beaucoup d'efforts, nous n'y sommes pas parvenu.

séance 9 projet final
Lors de cette séance et les jours de la semaine qui ont suivi nous avons du changé notre projet afin d'avoir au final un objet qui marche car nous n'avons pas réussi à faire marcher le multiplexeur comme nous le voulions.
Nous sommes donc repartis sur une station météo basique marchant sur l'arduino uno affichant la température, l'humidité, la luminosité et la pression. Pour cela, nous avons utilisé le grove barometer sensor BME280 (1) fonctionnant en I2C nous donnant tout sauf la luminosité donnée par le grove light sensor (3) marchant en analogique. Pour l'affichage, nous voulions afficher les valeurs une par une en gros sur un grove OLED Display 0.96 inch (4) cependant la fonction permettant d'agrandir la taille des caractères pour une raison mystérieuse ne marchait pas donc nous avons décidé au final d'afficher les données recueillies par le baromètre dessus. La luminosité est affichée sur la grove led bar (2) de sorte à ce que quand la luminosité est faible, peu de leds s'allument et quand elle est forte, beaucoup de led s'allument.

                 (1)                                                    (2)                                                                               (3)
 

                                                         (4)

Nous avons donc branché l'écran et le baromètre sur les ports I2C, le light sensor sur le port A0 et la led bar sur le port D2(cf photo).

Pour ce qui est du code, il est assez simple. On inclue tout d'abord les bibliothèques nécessaires et on initialise tous nos composants. Ensuite dans la boucle, nous récupérons les données du capteur de luminosité et nous affichons toutes les mesures sur l'écran Oled (d'où le grand nombre de SeeedOled.xxxx). Et pour finir nous affichons la graduation sur la barre de led.
Voici le code faisant fonctionner notre projet :
#include <Wire.h>
#include <SeeedOLED.h>
#include <Arduino.h>
#include <SeeedOLED.h>
#include "Seeed_BME280.h"
#include <Grove_LED_Bar.h>

Grove_LED_Bar bar(3, 2, 0);
BME280 bme280;

void setup() {
 
 float pressure;
 Wire.begin();
 SeeedOled.init(); 
 SeeedOled.clearDisplay(); 
 SeeedOled.setNormalDisplay(); 
 SeeedOled.setPageMode(); 
 SeeedOled.setTextXY(0, 0); 
 bme280.init();
 bar.begin();
 bar.setGreenToRed(true);
}

void loop() {
 int value = analogRead(A0);
 value = map(value, 0, 800, 0, 10);
 SeeedOled.clearDisplay();
 SeeedOled.setTextXY(0, 1);
 SeeedOled.putString(" temperature");
 SeeedOled.setTextXY(1, 0);
 SeeedOled.putString(" ");
 SeeedOled.putFloat(bme280.getTemperature());
 SeeedOled.putString("C");
 SeeedOled.setTextXY(3, 0);
 SeeedOled.putString(" humidite");
 SeeedOled.setTextXY(4, 0);
 SeeedOled.putString(" ");
 SeeedOled.putNumber(bme280.getHumidity());
 SeeedOled.putString("%");
 SeeedOled.setTextXY(6, 0);
 SeeedOled.putString(" pression");
 SeeedOled.setTextXY(7, 0);
 SeeedOled.putString(" ");
 SeeedOled.putNumber(bme280.getPressure()/100);
 SeeedOled.putString(" hPa");
 bar.setLevel(value);
 delay(5000);
}

Cela donne cet affichage (sans la led bar car nous avons oublié de le prendre en photo)

Il nous faut maintenant créer une boîte permettant de contenir tout le matériel et d'afficher les données recueillies par nos capteurs. Nous avons décidé d'utiliser la découpeuse laser car c'est rapide, et nous permet de graver des choses sur la boîte. Il faut cependant prévoir des trous pour la ventilation car le baromètre est dans la boîte, un trou pour l'alimentation de l'arduino, un pour l'écran, un pour la led bar et un pour le light sensor car il doit être à l'extérieur. Malheureusement pour nous, le port permettant de brancher ce dernier est du même côté que le capteur (cf 3). Il faut aussi prévoir des encoches afin que tout s'emboîte. Nous avons donc opté de le mettre devant de sorte à ce que le capteur soit à l'extérieur et le câble à l'intérieur. D'un point de vue design, nous avons décidé de faire sur la face avant une sorte de visage avec les afficheurs étant les yeux, un sourire gravé en dessous et le light sensor sortant au-dessus des yeux avec un petit bout rectangulaire de bois pour boucher l'espace en trop. Nous avons aussi gravé son nom le logo de Sorbonne Université ainsi que son nom : Jean-Eudes the weather station (nous l'avons choisi car nous trouvions le décalage entre un nom bien français suivi de la fin du nom en anglais drôle). La boîte fait 9*9*9cm et doit être découpée en bois de 6mm d'épaisseur pour toutes les pièces sauf l'avant qui elle doit être de 3mm. Cela nous donne ce dessin :

boite-projet-fin.svg
Pour finir le design de notre boîte, nous avons décidé de lui rajouter des bras et un chapeau trouvés sur thingiverse à l'aide des imprimantes 3D :
bras chapeau
Voici donc à quoi ressemble Jean-Eudes quand il est totalement assemblé

Projets personnels
Vitaly POPOFF
Lors de cette UE nous devons réaliser un objet en 3D à imprimer ainsi qu’un objet réalisé à l’aide de la découpeuse au laser.
Pour l’objet en 3D j’ai décidé de réaliser un dé. Pour ce faire, j’ai utilisé le logiciel OpenSCAD en créant des trous dans un cube à l’aide de cylindres pour marquer les nombres sur les faces du dé. Cela nous donne ce code et donc cette forme :

Je l’ai ensuite imprimée avec une taille de 30mm par côté et en remplissage de 10 % car le dé n’a pas besoin d’être plein. Cependant, je me suis rendu compte après impression que le dé ne roulait pas très bien à cause de ses bords en angle droit. Plutôt que de réimprimer avec les bords arrondis, j’ai décidé de poncer les bords et les coins avec du papier de verre afin d’économiser une impression. Voici le résultat final :

Pour l’objet dessiné en 2D, j’ai décidé de réaliser un puissance 4. Cependant c’est un objet en 3D donc il va falloir réaliser plusieurs pièces. La première version ressemble à ceci :

La pièce numéro 1 est le panneau à la verticale en face des joueurs. Les cubes rouges permettent aux joueurs de voir où sont les jetons et les indentations sur les côtés permettent aux pièces de s’emboîter entre elles.

Il a fallu la découper 2 fois avec une épaisseur de 5mm.

La pièce numéro 3 est à la verticale et permet de relier les deux panneaux tout en laissant assez d’espace pour les jetons. Son rectangle central est de 5mm de largeur et ses cubes qui dépassent sur les côtés aussi permettant de s’encastrer parfaitement (théoriquement) dans les trous des panneaux. Il a fallu la découper 2 fois avec une épaisseur de 5mm.
La pièce numéro 4 est ce qui permet aux jetons de ne pas passer d’une colonne à une autre. Ces bloqueurs s’incrustent dans les petits trous en haut du panneau central grâce aux rectangles sortant tout en haut de la pièce.
Il a fallu la découper 5 fois avec une épaisseur de 3mm.
La pièce numéro 2 est ce qui maintient les deux panneaux par le bas. Les rectangles «sortant» de la pièce permettent à la pièce de s’emboîter dans les panneaux et les petits carrés à l’intérieur permettent aux bouts des pièces 4 de s’incruster dans la pièce afin d’assurer leur stabilité.
Il a fallu la découper 1 fois avec une épaisseur de 5mm.
La pièce 5 est le jeton mais dû à des complications, elle a été modifiée plus tard.
Il faudra néanmoins la découper 42 fois avec une épaisseur de 5mm.
Je pensais tout d’abord découper toutes les pièces en bois mais ai finalement décider de les découper en PMMA et quelle erreur. Je savais qu’il fallait prendre en compte l’épaisseur du laser pour que les pièces s’emboîtent parfaitement mais je me suis dit que je rattraperai les erreurs à l’aide de colle. Après la découpe de toutes les pièces sauf les jetons, je me suis rendu compte que sur certaines pièces il y avait des problèmes d’emboîtement, cela à cause du plastique ayant fondu et de l’épaisseur du laser étant non négligeable. L’emboîtement entre les panneaux et les pièces 2 et 3 est impossible car ces dernières sont trop petites par rapport aux trous dans les panneaux. Ceci est un problème facilement réglable avec de la colle. Cependant, l’emboîtement des pièces 4 avec les 1 et 2 sont impossible car le plastique a fondu réduisant la taille des trous. Heureusement, à l’aide de papier de verre, il est possible de réduire l’épaisseur des pièces 4 rendant finalement leurs emboîtements possible. La forte température de découpe a aussi déformé les bâtonnets des pièces 4. A cause de toutes ces imprécisions, les jetons ronds ne pourraient pas (ou du moins difficilement) rentrer dans le puissance 4, j’ai donc décidé de découper à la place des jetons de 3mm d’épaisseur rectangulaires de taille 11mm*15mm.
Cela nous donne au final un puissance 4 ressemblant à ceci :

dé.FCStd
puissance-4.svg

Projet personnel Clément

En utilisant le logiciel de Design Freecad, j'ai réalisé une équerre (objet 2D). Je pensais l'imprimer par impression 3D, mais il faut la réaliser avec une machine de découpe. Je vais donc recréer un fichier Inkscape.
L'objet est simple à réaliser : on réalise une esquisse 2D de l'equerre, puis on réalise une protusion de 1mm.

Objet 3D : boule de noël
.
Pour ce faire, j'ai dessiné une esquisse, représentant une tranche de la boule. J'ai ensuite effectué une rotation pour obtenir l'ensemble.

Projet personnel Pierre :

         Mon objet en 2D est une pancarte décorative pour un Sound System que j'ai réalisée avec le logiciel INKSCAPE. grâce à la palette de couleur conçue pour les découpeuses et graveuses laser Trotec que j'ai du téléchargé sur mon ordinateur, j'ai tracé cette pancarte de 30cm de long pour 20 m de large donnant l'ordre de découper lorsque les tracés sont rouges et de graver lorsqu'ils sont noirs.

Néanmoins j'ai rencontré DEUX SOUCIS lors de la réalisation :
 - le premier problème est que la police d'écriture (qu'on voit à l'écran) s'est enlevée sur le rendu 2D du logiciel de la découpeuse Trotec et le texte s'est également décentré sans raison
- le deuxième soucis provient de moi, j'ai oublié de bien calibrer la position de la pancarte par rapport à la planche de bois ce qui a rogné une partie à droite de la pancarte... (snif)

         

  Quant à mon objet 3D, j'ai cherché sur Thingiverse plusieurs dizaines d'objets avant de tomber sur une statue un peu modifié de Buddha qui ressemble aux photos ci-dessous. C'est une décoration qui serait la bienvenue dans ma chambre.

                                       

Je n'ai pas utilisé de logiciel 3D particulier comme FREECAD, et j'aurais peut être dû d'ailleurs. J'ai tout de même géré les supports nécessaires à l'impression correcte de ma pièce, les dimensions et la finesse d'impression sur le logiciel IDEA MAKER.

Séance 10 : oraux de présentation
Nous avons présenté notre projet, et assisté à la présentation de ceux des autres.
Bilan de l'UE : nous avons appris des fonctionnements très intéressants (logiciels, machines, montages, etc). Ces compétences nous resterons et peut-être nous aurons à revenir au Fablab un jour.

Analyz'Air - Station météo portable


Membres du groupe :
ianel AKOU, Paul BOUDET, Rose PEYBERNES, Mathéo TONNEYCK : Nous sommes tous les quatre en Cursus Master en Ingénierie Physique à Sorbonne Université.

Cette page Wiki a pour but de présenter l'évolution de notre projet de l'UE FabLab au cours de ces 10 séances.

Séances de découvertes et de prise en main du matériel du FabLab

Séance : Découverte du FabLab
Nous avons commencé la séance par une présentation du principe et du fonctionnement du Fablab , nous permettant d'en découvrir davantage notamment sur l’origine de ce réseau de labos, leur localisation et l'importance de la documentation qui y est associée. Par la suite, nous avons détaillé les objectifs et le programme de l'UE . Une visite du Fablab nous a ensuite permis de découvrir l'ensemble des machines et composants avec lesquels nous pourrons travailler afin de confectionner et concrétiser notre projet final : imprimantes 3D, découpeuses laser, fraiseuses numériques, cartes Arduino. Cette année, nos projets doivent être portés sur le thème des mesures environnementales à l'aide de capteurs . Après avoir formé des groupes de projet, nous avons exploré le wiki du fablab, trouvé la bibliothèque de documents à notre disposition et émis les premières idées pour notre projet final. Mais avant de nous lancer dans ces projets, nous devons prendre en main les logiciels de programmation et de modélisation avec lesquels nous n’avons encore jamais travaillé. C’est donc ce que nous ferons dès la prochaine scéance en commençant par les cartes Arduino UNO.

Séance 2 : Prise en main de l'Arduino UNO
Partie théorique :

Pour débuter la séance, nous avons eu une discussion autour de l'évolution de l'électronique en dates ( de la diode de John Fleming en 1904 au M5Stack en 2017).

Par la suite, nous avons été introduits aux cartes Arduino dans les détails nous permettant de comprendre leur fonctionnement et la façon de communiquer avec la suite Arduino IDE. Chaque carte supporte plusieurs composants ayant chacun une fonctionnalité précise.

                                                                           

Grâce au logiciel Arduino,  nous avons commencé à découvrir le langage des cartes et la bonne façon de transmettre une volonté à notre carte. Nous avons défini des termes et fonctions pouvant être présents dans les codes que nous pouvons avoir à utiliser pour notre projet :

Exemples :
SETUP : La fonction setup() est appelée au démarrage du programme. Cette fonction est utilisée pour initialiser les variables, les librairies utilisées.
LOOP : cette fonction appelle à répéter en boucle une certaine action.

IF / ELSE : if (la condition) —> ce terme ouvre une condition; si cette condition est vérifiée par le programme il l’applique sur le système. A la fin de la condition on ajoute deux accolades et on y insert tout ce qui sera executé si et seulement si la condition est vérifiée.

                  else —> (peut se traduire par sinon) ce terme est une instruction d’alternative; si la condition imposée n’est as vérifiée, il executera de la même façon les instruction entre accolades.

Pour finir sur la théorie, nous ne sommes pas encore en capacité de coder un programme suffisemment complet pour un projet comme nous devons rendre à la fin du semestre. C’est ppourquoi nous nous servons de bibliothèques de codes qui sont à disposition sur inernet pour trouver des programmes déjà rédigés et complets que nous avons seulement à modifier. Pour les utiliser, nous avons appri que pour brancher n'importe quel module à une carte Arduino et trouver son code il y a une démarche à suivre pour avoir un résultat rapide et de qualité :

1) Identifier le module avec son nom ou une référence.
2) Trouver sa fiche technique (si elle existe) sur le site seeed studio
3) Correctement appréhender le module et comprendre son mécanisme et sa fonctionnalité
4) Télécharger la bibliothèque qui lui correspond et l'introduire dans le programme sur Arduino
5) Choisir un programme sur le site qui répond à la demande et le transférer dans Arduino
6) Brancher les composants 

Partie pratique :

Après avoir bien compris le fonctionnement d'Arduino, nous avons branché une carte Arduino à notre ordinateur. Sur le logiciel, à l'aide des exemples de codes à disposition nous sommes parvenus premièrement à faire de simples manipulations comme allumer la LED de la plaque et la faire clignoter à des intervalles de temps différents. Par la suite, nous avons superposé un shield sur notre carte Arduino et y avons branché sur l'un des ports I2C un capteur de température et d'humidité avec un connecteur grove . De nouveau à l'aide d'un exemple de code, nous sommes parvenus à afficher la température et l'humidité de la salle.Par la suite avec la fonctionnalité module en série, nous avons réussi à mesurer toutes les deux secondes la température et l'humidité. Pour être sur que notre dispositif fonctionnait nous l'avions placé à différents endroits et vérifié qu'il y avait bien une variation des valeurs (dans les mains, sur une table, dans un pull). Suite à cela, nous avons voulu améliorer notre dispositif en numérisant les valeurs sur un écran en temps réel. Pour cela, nous avons d'abord choisi le bon programme pour relier l'écran à notre carte. Nous avons ensuite combiné le programme du capteur et celui de l'écran pour afficher les valeurs. Nous avons ainsi obtenu le programme suivant :

#include <Arduino.h>
#include <Wire.h>
#include "SHT31.h"
#include <Wire.h>
#include "rgb_lcd.h"

rgb_lcd lcd;
 
const int colorR = 255;
const int colorG = 0;
const int colorB = 0;

SHT31 sht31 = SHT31();
 
void setup() { 
 Serial.begin(9600);
 while(!Serial);
 Serial.println("begin..."); 
 sht31.begin(); 

}
void loop() {
 float temp = sht31.getTemperature();
 float hum = sht31.getHumidity();
 Serial.print("Temp = "); 
 Serial.print(temp);
 Serial.println(" C"); //The unit for Celsius because original arduino don't support speical symbols
 Serial.print("Hum = "); 
 Serial.print(hum);
 Serial.println("%"); 
 Serial.println();
 delay(1000);
 // set up the LCD's number of columns and rows:
 lcd.begin(16, 2);
 
 lcd.setRGB(colorR, colorG, colorB);
 
 // Print a message to the LCD.
 lcd.setCursor(0, 0); 
 lcd.print("Temp = "); 
 lcd.print(sht31.getTemperature());
 lcd.setCursor(0, 1);
 lcd.print("Humidity = "); 

 // print the number of seconds since reset:
 lcd.print(sht31.getHumidity());
 
 delay(2000);
}
Nous avons ainsi obtenu un capteur de température et d'humidité qui mesurait ces paramètres toutes les deux secondes et un écran qui affichait ces deux valeurs.

À la fin de la séance, nous avons pu avoir accès à d'autres types de capteurs que nous pouvons utiliser dans notre projet final : capteur de lumière, CO2, gaz, qualité de l'eau, débit de l'eau, pression.

Matériel utilisé en image et vidéos :
Carte Arduino                                  Shield

Capteur de température et d'humidité Connecteur bosquet

Ecran pour Arduino
La prochaine séance nous travaillerons sur la représentation et le dessin en 2 et 3 dimensions . Nous verrons aussi l'utilité et le fonctionnement de M5Stack qui est un système de plusieurs modules que l'on peut approcher par programmation avec la suite Arduino IDE.

Séance 3 : Découverte du dessin 2D/3D, de la découpe laser et de l'impression 3D
Pour cette séance nous sommes concentrés sur la représentation en deux dimensions et en trois dimensions avec plusieurs logiciels :

INKSCAPE : le logiciel Inskcape permet de réaliser des dessins vectoriels gratuitement et qui reste relativement abordable en utilisation. Nous nous en servirons pour la modélisation destinée à la découpe laser. Nous avons commencé par faire nos premiers pas sur Inskape en reproduisant un dessin géométrique aléatoire proposé par notre professeur avec plusieurs paramètres de dimensions :

                                                                           
Il est aussi important de connaître l'existence de Makercase : qui est une proposition en ligne d'une banque de modèles de boîtes de toutes les sortes déjà réalisées. Ce sont des formes basiques que l'on peut ensuite modifier sur Inskcape en les importantes.

OPENSCAD : est un logiciel libre de modélisation paramétrique gratuit. La modélisation sur ce logiciel se fait par programmation avec un langage C++. Une aide-mémoire existe sur le site officiel du logiciel où l'on retrouve les fonctions de base pour créer des designs relativement élaborés. Sur ce logiciel, nous avons modélisé un cube percé par 3 cylindres : 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

FREECAD : FreeCAD est un modeleur 3D paramétrique open-source conçu principalement pour concevoir des objets réels de toute taille. La modélisation paramétrique nous permet de modifier facilement nos conceptions en revenant dans l'historique du modèle et en modifiant ses paramètres. Ce logiciel permet notamment de générer des fichiers 3d au format STL (qui est un format adapté aux impressions 3D mais qui ne peut plus être modifié). En effet, il faut créer au préalable un fichier de conception que l'on peut modifier à notre aise puis l'exporter en fichier STL pour l'impression ou la découpe laser. Nous avons de nouveau modélisé le même cube troué :

                                                                           

Nous avons ensuite transféré notre modélisation 3D de cube percé à une imprimante 3D et nous avons lancé l'impression. Nous avons fait de même pour la découpeuse laser. L'objectif était de comprendre comment transferer le modèle obtenu grâce aux logiciels de dessin sur les machines de conception. 

NB : La durée d'une impression 3D peut dépendre de la taille, du choix de remplissage de l'objet à imprimer ou encore du filament utilisé. Il arrive parfois que la buse se bouche ou que l'impression rate à cause de mauvaises dimensions. Par conséquent, il faut prévoir une marge de temps pour que le projet soit prêt à la date butoir au cas où il serait nécessaire de recommencer une impression.

A la prochaine scéance nous apprendrons à programmer un M5Stack et nous étudierons ses avantages/desavantages par rapport à la carte Arduino UNO.

Séance 4 : Prise en main du M5Stack
Découverte du M5Stack
Au cours de cette séance, l'objectif était de comprendre le fonctionnement du M5Stack. Pour rappel, un M5Stack est un kit de développement intégré autour de l'ESP32. Il se compose d'une partie centrale appelée core , qui intègre notamment un écran et un lecteur de cartes SD. Il faut aussi savoir que le M5Stack répond au langage   C / C++  via l' IDE Arduino. Cela signifie que les codes utilisés pour la programmation d'une carte Arduino peuvent aussi être utilisés pour la programmation de M5Stack. Attention ! --> il faut tout de même effectuer quelques modifications : changer toutes les adresses à la carte Arduino en adresses au M5Stack (ex : #include <Arduino.h> en #include <M5Stack.h>). Il faut aussi bien penser à aller changer/vérifier le port et l'entrée sélectionnée pour transférer le programme.
Après avoir compris ce qu'était un M5Stack et comment nous pouvions nous en servir, nous sommes passés à la partie pratique. Celle-ci a été facilitée par l'existence du site internet github proposant de nombreux codes standards pour donner des missions basiques au M5Stack. Notre première mission étant d'afficher "Hello World" sur l'écran du M5Stack, nous nous sommes donc servis du programme HelloWorld.ino qui se trouve dans le dossier Basics des exemples :
/*
*******************************************************************************
* Copyright (c) 2021 by M5Stack
* Equipped with M5Core sample source code
* 配套 M5Core 示例源代码
* Visit for more information: https://docs.m5stack.com/en/core/gray
* 获取更多资料请访问: https://docs.m5stack.com/zh_CN/core/gray
*
* Describe: Hello World
* Date: 2021/7/15
*******************************************************************************
*/
#include <M5Stack.h>

/* After M5Core is started or reset
the program in the setUp () function will be run, and this part will only be run
once. 在 M5Core
启动或者复位后，即会开始执行setup()函数中的程序，该部分只会执行一次。 */
void setup() {
 M5.begin(); // Init M5Core. 初始化 M5Core
 M5.Power.begin(); // Init Power module. 初始化电源模块
 /* Power chip connected to gpio21, gpio22, I2C device
 Set battery charging voltage and current
 If used battery, please call this function in your project */
 M5.Lcd.print("Hello World"); // Print text on the screen (string)
 // 在屏幕上打印文本(字符串)
}

/* After the program in setup() runs, it runs the program in loop()
The loop() function is an infinite loop in which the program runs repeatedly
在setup()函数中的程序执行完后，会接着执行loop()函数中的程序
loop()函数是一个死循环，其中的程序会不断的重复运行 */
void loop() {
}
Après avoir réussi cette étape, nous avons branché le même capteur d'humidité et de température qu'à la séance 2 et nous avons essayé d'afficher les valeurs sur l'écran du M5Stack. Pour cela, notre première idée était de réutiliser notre programme de la séance 2 en le modifiant pour qu'il soit compris par le M5Stack. Nous avons obtenu ceci :

                                                                               
Cependant, les données s'affichaient à la suite et en très petit. Après avoir passé un certain temps à chercher comment modifier la taille, la police et la couleur des écritures, nous ne sommes pas parvenus à un résultat concluant. Mais un groupe de camarades a écrit un code qui fonctionne parfaitement (il s'agit du groupe B1). Nous les remercions pour le travail efficace qu'ils ont fourni. Voici leur code :

#include <Arduino.h>
#include <M5Stack.h>
#include <Wire.h>
#include "SHT31.h"
#include "Free_Fonts.h" 
 
SHT31 sht31 = SHT31();
 
void setup() { 
 Serial.begin(9600);
 while(!Serial);
 Serial.println("begin..."); 
 sht31.begin(); 
 M5.begin(); // Init M5Core. 初始化 M5Core
 M5.Power.begin(); // Init Power module. 初始化电源模块
 
}
 
void loop() {
 float temp = sht31.getTemperature();
 float hum = sht31.getHumidity();
 M5.Lcd.setFreeFont(FSB18);
 M5.Lcd.print("Temp = ");
 M5.Lcd.print(temp);
 M5.Lcd.println(" C");
 M5.Lcd.print("Hum = ");
 M5.Lcd.print(hum);
 M5.Lcd.println(" %");
 M5.Lcd.println(); 
 delay(1000);
}

Création de projet personnel

Projets Personnels
Après avoir travaillé sur les M5Stacks, nous avons chacun avancé sur nos mini projets dont l'objectif est de modéliser un objet en 3D et de l'imprimer mais aussi de prototyper un objet et de le découper/graver sur une planche de bois avec la découpeuse laser.

Chaque membre du groupe détaillera son projet ci-dessous :

Paul Boudet
Modélisation d'un marteau en 3D :
Pour modéliser mon objet en 3D, j'ai utilisé le logiciel FREECAD qui a été introduit lors de la séance 2. J'ai créé un nouveau document puis la fenêtre Part Design. Grâce à cette fenêtre, j'ai réalisé une esquisse d'un rectangle puis utilisé l'outil protrusion afin de créer un pavé en 3D à partir de cette esquisse de longueur l= 30 mm, de largeur L= 10 mm et de hauteur h = 15 millimètres. Une fois mon pavé réalisé, j'ai sélectionné une des faces du pavé et réalisé une nouvelle esquisse, d'un cercle cette fois ci, sur cette face. A partir de cette esquisse d'un cercle, en utilisant l'outil protrusion, j'ai créé un cylindre de 30 mm de hauteur dont la base est le cercle réalisé en esquisse.J'ai ensuite fait un trou dans ce cylindre à l'aide de l'outil préconisé. Ces étapes m'ont permis de modéliser un petit marteau en 3D de dimensions 50*50 mm :

 
A droite, sur le fond bleu ce situe la modélisation du marteau.

A gauche on retrouve la fenêtre "vue combinée", qui résume les actions réalisées afin de modéliser cette pièce. Cette vue nous permet, si l'on souhaite modifier notre objet, de réaliser ces modifications sur une partie spécifique de notre objet au lieu de tout recommencer.

Enfin, en haut, sur la ligne du bas, se trouvent les outils du mode part design qui m'ont permis de modéliser cette pièce.

Une fois, la modélisation terminée, il faut exporter le fichier en format STL afin de l'imprimer à l'aide des imprimantes 3D du Fablab qui sont des imprimantes FDM Raise 3D Pro 2. Une documentation sur le fonctionnement de ces imprimantes est disponible dans l'onglet Tutoriels puis Machines, du wiki.

Voici un lien vers mon fichier : pièce-3D-2.FCStd
Documentation dessin 2D Paul BOUDET :

Pour réaliser mon dessin en 2D, j'ai dessiné mon objet dans le logiciel de dessin vectoriel INKSCAPE . Grâce à ce logiciel, j'ai dessiné un motif connu par les amateurs du manga Naruto. Ce motif esthétique représente les yeux de certains personnages dans le manga et est nommé "sharingan" :

 
Pour dessiner ce motif, j'ai utilisé les outils mis à ma disposition à droite de l'interface. A droite se situe une fenêtre qui m'a permis de gérer les fonds et les contours comme je le souhaitais. Notons, que les motifs de couleur rouge seront découpés, tandis que ceux de couleur noire seront gravés.

Afin de dessiner le cercle plein au centre et les cercles noirs et rouges autour j'ai tout simplement utilisé l'outil "créer des cercles" situé à gauche. J'ai ensuite pu gérer la couleur et le fond comme je le voulais grâce à la fenêtre de droite. Pour dessiner les motifs un peu plus mis au point sur le cercle vide noir, j'ai utilisé l'outil "tracer des courbes de Bézier et des segments de droite" pour réaliser des courbes. Ce dessin a été fait en dimension 80 mm par 80 mm.

Une fois ce modèle enregistré, il sera gravé et découpé à l'aide des découpeuses laser présentes au Fablab qui inclura des formats SVG. Sont présents au fablab, une découpeuse laser Trotec Speedy 360 et une découpeuse laser Trotec Speedy 100. Une documentation sur le fonctionnement de ces découpeuses est présente dans l'onglet Tutoriels puis Machines, du wiki.
Photos du résultat obtenu :

Voici un lien vers mon fichier : dessin-1.svg

Mathéo Tonneyck
Modélisation 2D et utilisation de la découpeuse laser :
Pour ce procédé, j'ai décidé d'utiliser Inkscape afin de reproduire le logo du CMI de Sorbone Université.
Pour cela, j'ai utilisé deux techniques.
La première technique consiste à le reproduire à la main avec les outils du logiciel :

Formes : cercle, cube
Texte
Caractéristiques et couleurs des objets

La deuxième technique consiste à utiliser l'outils Trace Bitmap du logiciel qui va vectoriser automatiquement l'image

Résultat obtenu :

lien vers le fichier svg : Logo_CMI.svg
Modélisation 3D et utilisation de l'imprimante 3D :
Dans le cadre de notre projet, nous aurons certainement besoin d'un système d'accroche pour des accessoires supplémentaires tel qu'un trépied donc j'ai décidé de travailler sur un système qui permet de viser un objet à un autre.
Pour ce faire, j'ai utilisé le logiciel Freecad.
J'ai utilisé deux techniques différentes pour chaque partie.
Pour le cube avec un trou fileté, j'ai utilisé l'outil "Hole" dans Part design que j'ai appliqué sur un cube déjà tracer.
Avec cet outils j'ai pu appliquer des paramètres pour y insérer un vis de taille avec des dimensions standard M10.
Tandis que pour créer la vis, j'ai utilisé la librairie "Fasterners" qui intègre de nombreux modèles de vis et d'écrous de différentes tailles pré-conçu nous n'avons plus qu'à appliquer des paramètres tel que le diamètre de la vis ou encore sa longueur.

Résultat obtenu :

Lien ver le fichier STL : Vis filletage fablab.stl

Rose Peybernes
Modélisation 3D :

Pour cette modélisation, je n'avais pas d'idée précise d'un objet à créer mais je voulais savoir s'il était possible d'imprimer un objet dans un autre objet et que celui-ci soit mobile. Comme nous ne devions pas faire un objet trop volumineux je me suis inspiré du travail que nous avons fait à la troisième séance et j'ai modélisé un cube 5x5cm avec une sphère d=2.5cm à l'intérieur à l'aide du logiciel OPENSCAD . Voici le code pour obtenir la modélisation 3D :
$fn=50;
//cube(5, center = true);
//cylinder(10, 4, 4, center = true);
//rotate([90, 0, 0])cylinder(10, 4, 4, center = true);
//rotate([90,90, 90])cylinder(10, 4, 4, center = true);

//rotate([90, 0, 0])cylinder(10, 2, 2, center = true);
 // rotate([90,90, 90])cylinder(3, 2, 5, center = true);
sphere( r = 2, d = 5);
difference (){
 cube(5, center = true);
 cylinder(10, 2, 2, center = true);
 rotate([90, 0, 0])cylinder(10, 2, 2, center = true);
 rotate([90,90, 90])cylinder(10, 2, 2, center = true);
}

                                         

Afin d'imprimer mon objet je me suis servi du tutoriel sur le wiki et j'ai aussi été aidée par le personnel du Fablab afin d'être sur que mon impression se fasse correctement. Je tiens à préciser que lorsque j'ai transféré mon fichier dans le logiciel d'impression, ce dernier m'a proposé des supports automatiquement et que ce n'est pas moi qui les ai modélisés. Pour cette impression j'ai donc utilisé une bobine de filament ABS et une imprimante  FDM Raise 3D Pro 2 dont les caractéristiques sont les suivantes :

Utilisation : Impression 3D à dépôt de filament
Volume maximal d'impression : 305mm*305mm*300mm.
Extrusion : directe, double-extrusion possible
Matières compatibles : bobines de filament PLA / ABS / HIPS / PC / TPU / TPE / NYLON / PETG / ASA / PP
Diamètre du filament : 1,75mm
Buse : laiton, 0.4mm
Logiciel : ideaMaker
Formats de fichiers requis : stl, obj

Modélisation et réglages sur logiciel d'impression :

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

NB : Bien que mon objet soit plutôt petit, l'impression à tout de même pris 3h. Il faut donc prévoir une plage de temps suffisante au cas où l'impression raterait et serait à refaire. J'ai obtenu un objet qui ressemblait exactement à ce que je voulais. On observe sur la sphère quelques imperfections liées à mon choix de précision moyenne pour la dépose du filament.

                                    Voici un lien vers mon fichier : modifiable --> cube avec sphere.scad

                                                final --> cube avec sphère final.stl
Modélisation 2D :
Pour mon dessin en 2D, je voulais faire un objet qui pourrait m'être utile et qui en même temps me ferait suffisamment travailler sur le logiciel pour le maîtriser. Je me suis donc servie de INKSCAPE  pour dessiner un jeu morpion de poche 10x10 cm. Pour cela j'ai du imaginer une espèce de petite boîte qui pourrait accueillir les pièces de jeu (2cm) et un plateau de jeu. Une fois que j'avais une idée arrêtée de toutes mes pièces, je me suis penchée sur le dessin 2D :

                       à noter que les éléments noirs sont gravés et les rouges découpés.

Pour la découpe laser j'ai utilisé une découpeuse laser Trotec Speedy 360 et une planche de bois de 3mm d'épaisseur.

Description : découpe et gravure de certains matériaux plans comme le contreplaqué et le PMMA
Caractéristiques techniques : équipé d'une lentille CO2 2,5" ou d'une lentille CO2 1,5"
Surface de travail : 813*508mm
Épaisseur max de découpe : environ 12mm, selon matériaux
Hauteur max de la pièce à usiner : ...
Matériaux compatibles : voir la  liste des matériaux utilisables
Logiciel : Ruby
Formats de fichiers requis : privilégier svg. En principe compatibilité ai, dxf, pdf, cdr + jpeg pour les gravures

Pour réaliser correctement la découpe je me suis de nouveau aidée du tutoriel.

Pour réaliser mon objet j'ai décidé de prendre du contre plaqué de 3mm d'épaisseur. Ainsi, les pièces du jeux et la boîte ne seront pas trop épaisses et donc pas trop grosses pour un objet de poche.
NB : Avant de lancer la découpe laser, il ne faut pas oublier de faire la focale du laser de la découpeuse.

                                                                               

Une fois tous les morceaux découpés, je les ai assemblés. Si certaines parties étaient trop épaisses, je les ai poncé pour être sûr que toutes les pièces s'emboitent correctement.  

                 
Voici un lien vers mon fichier : modifiable et final --> dessin modifiable.svg

Yanel Akou
Modélisation 3D :

De mon côté, j'ai utilisé le logiciel fusion 360 pour modéliser mon objet en 3 dimensions. Etant un joueur d'Ultimate Flying Disc, mon projet était de créer un ustensile, appelé "disc clip", permettant de pouvoir accrocher un disque (freesbie) à son sac. J'ai donc pu d'abord modéliser en 2D une esquisse de la forme de mon objet pour ensuite utiliser l'outil extrusion afin de lui donner de l'épaisseur et obtenir un premier objet en 3 dimensions. Par la suite, j'ai travaillé sur cet objet brut en lui arrondissant les angles pour lui donner un aspect plus ergonomique. Enfin, en utilisant toujours l'outil d'extrusion mais cette fois ci en mode différence j'ai pu faire des trous à certains endroits afin d'obtenir un gain de matière inutile.Pour finir, j'ai pu exporter mon fichier sous format STL,

 

Découpe laser :

Mon projet de découpe laser était une boite en bois avec des trous, qui accueillerait une bougie et illuminerait la pièce avec certains motifs. Afin de réaliser le patron de la boite je me suis rendu sur un site qui modélise ce genre de patron "box maker", comme montré en cours. De cette manière j'ai obtenu un patron de ma boite aux dimensions souhaitées. Par la suite, j'ai utilisé le logiciel Inkscape afin de rajouter sur ce patron les motifs en étoiles de tailles différentes qui seront découpées dans les paroisses de la boite afin de laisser passer la lumière. Pour finir j'ai pu exporter le fichier de mon projet sous format SVG.

Projet Final - Station météorologique portable

Séance 5 à 8 : Projet Final - Création du programme de la station météorologique
Nous avons décidé de partir sur une station météo portable capable de mesurer la température, l'humidité, la pression et doté d'un GPS. Elle serait destinée aux randonneurs pour des expéditions en montagne pouvant s'étendre sur plusieurs jours. Cette station aura la forme d'un pavé droit : une boîte dans laquelle seront rangés les capteurs et l'antenne GPS. Le M5Stack sera intégré dans la boîte de façon à ce que l'écran et les boutons soient accessibles. Si nous terminons en avance, nous voudrions trouver un système pour l'accrocher sur un sac ou y accrocher une perche pour avoir un meilleur maintenu en marche.

Pour fabriquer cette station météo portable, nous n'utiliserons que des capteurs ayant des ports I2C. Nous allons donc utiliser un hub contenant des ports I2C que nous attribuerons à tous nos capteurs. Ce hub sera lui même connecté à notre M5stack qui affichera sur un écran les données relevées et sur un autre les données recueillies à l'aide de l'antenne GPS.
Hub I2C :

Voici tous les capteurs que nous allons utiliser et leurs références :

¤ Température et Humidité (SHT31) :                          

¤ Pression (DPS310) :

GPS :

Pendant l’ensemble des séances qui ont suivi, nous avons travaillé sur l’écriture des codes. Notre stratégie était de d’abord rédiger le code correspondant à chaque composant et ensuite de le combiner avec les autres. Pour chacun, nous avons commencé par chercher un code exemple sur  seeed studio que nous avons ensuite modifier pour qu’il correspondent à notre projet. 

Codage GPS
Voici le programme pour faire fonctionner notre module GPS, trouver sur le site hackster.io

https://m5stack.hackster.io/ptschulik/simple-gps-tracker-d3500e
Après avoir compris ce programme, nous avons réalisé quelques modifications telles que changer la langue de base qui était l'allemand en français ainsi que réaliser des modifications au niveau du graphisme.

/****************************************************************************************/
/* GPS Logger with M5Stack and M5 GPS Module */
/* Version: 1.0 */
/* Date: 27.06.2019 */
/* */
/* Special features: */
/* Key A: Change language between German and Englis */
/* Key B: Changes format of location data */
/* Key C: Change brightness of display */
/* */
/* Used library: */
/* Tiny GPS Plus: https://github.com/mikalhart/TinyGPSPlus */
/* */
/****************************************************************************************/

#include <M5Stack.h> /* Include M5 Stack library */
#include <TinyGPS++.h> /* Include Tiny GPS++ library */

/* Definitions */
#define NOTE_DH2 661

/* Constants */
const byte DELAY_READ = 10; /* Delay between two reads: 10 = 100ms */
const byte DELAY_CHECK_CONST = 100; /* Delay to check if any data received 100 * 10 = 1 sec */
const byte MINUMUM_SAT = 4; /* Minumum number of satellites before fix is accepted */
const byte UTC_CET = 2; /* Time difference from UTC to CET */

/* Variables */
boolean UPDATE_FLAG; /* Display update flag: TRUE = Update, FALSE = No update */
boolean LOC_UPDATE_FLAG; /* Location update flag: TRUE = Update, FALSE = No update */
boolean ALT_UPDATE_FLAG; /* Altitude update flag: TRUE = Update, FALSE = No update */
boolean SPEED_UPDATE_FLAG; /* Speed update flag: TRUE = Update, FALSE = No update */
boolean SAT_UPDATE_FLAG; /* Nr. of sattelites update flag: TRUE = Update, FALSE = No update */
boolean HDOP_UPDATE_FLAG; /* HDOP update flag: TRUE = Update, FALSE = No update */
byte LOOP_COUNTER; /* Generic loop counter for delay */
byte DELAY_CHECK = 0; /* Delay to check if any data received */
byte LCD_BRIGHTNESS = 250; /* LCD brightness value (0-250) */
byte MENU_LANGUAGE = 0; /* Menu Language 0 = German, 1 = English */
byte GPS_FORMAT = 0; /* GPS format 0 = Decimal degree, 1= Degree, Minutes, Seconds */ 
byte GPS_STATUS; /* GPS status: 0 = No GPS receiver detected, 1 = No valid GPS fix, 2 = Valid GPS data */ 
unsigned int NO_OF_SAT; /* Number of satellites */ 
unsigned int CHARS_PROCESSED = 0; /* Number of procesed chars */ 
unsigned int OLD_CHARS_PROCESSED = 1; /* Number of procesed chars */ 
unsigned int OLD_NO_OF_SAT; /* Old number of satellites */ 
unsigned int OLD_HDOP; /* Old HDOP value */
int OLD_SEC = 0; /* Old second */ 
int OLD_ALTITUDE; /* Old altitude value */
int OLD_SPEED; /* Old speed value */ 
float OLD_LOC_LAT; /* Old lateral location */ 
float OLD_LOC_LNG; /* Old longitudinal location */
/* Table for day of month */
unsigned char DAY_OF_MONTH[] = {31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30,31};
char CONVERTED[32]; /* Conversion string for display */

TinyGPSPlus gps; /* Reference the TinyGPS++ object */
HardwareSerial GPSRaw(2); /* By default, GPS is connected with M5Core through UART2 */

/****************************************************************************************/
/* Init routine */
/****************************************************************************************/
void setup() 
{
 M5.begin(); /* Start M5 functions */
 GPSRaw.begin(9600); /* Init GPS serial interface */
 M5.Lcd.setBrightness(LCD_BRIGHTNESS); /* Set initial LCD brightness */
 delay (2000); /* 2000ms init delay */
 UPDATE_FLAG = true; /* Set update flag true */
 LOC_UPDATE_FLAG = true; /* Set location update flag true */
}

/****************************************************************************************/
/* Main routine */
/****************************************************************************************/
void loop() 
{
 while (GPSRaw.available() > 0) /* Check if new GP data is available */
 {
 gps.encode(GPSRaw.read()); /* Read until no more data is available */
 }

 CHARS_PROCESSED = gps.charsProcessed(); /* Read processed chars */

 /* No chars processed or no more data received --> Checked every 10ms ? */
 if ((CHARS_PROCESSED < 10)|| (CHARS_PROCESSED == OLD_CHARS_PROCESSED)) 
 {
 if (DELAY_CHECK < 230) /* Prevent variable from overflow */
 {
 DELAY_CHECK = DELAY_CHECK + 10; /* Increase delay check if any data received each 10ms by 10 */
 }
 }
 else /* No chars received ? */
 {
 DELAY_CHECK = 0; /* Reset delay check if any data received */
 }

 /* Case 1: Timeout */
 if (DELAY_CHECK > DELAY_CHECK_CONST) 
 {
 if (GPS_STATUS > 0) /* Was already in an other GPS status ? */
 {
 UPDATE_FLAG = true; /* Set update flag true */ 
 }
 if (UPDATE_FLAG == true) /* Update flag true ? */
 {
 SUB_DISPLAY_NO_REC(); /* Call sub routine to display no receiver error message */ 
 UPDATE_FLAG = false; /* Set update flag false */
 } 
 GPS_STATUS = 0; /* Set GPS status 0 */
 }
 else /* New data received correctly ? */
 {
 if (GPS_STATUS == 0) /* GPS state 0 ? */
 {
 GPS_STATUS = 1; /* Set GPS status 1 */
 UPDATE_FLAG = true; /* Set update flag true */
 }
 }

 /* Case 2: Receiver found and data are received but no GPS signal --> Status 1 */
 if (GPS_STATUS == 1) /* GPS status is 1 ? */
 {
 /* Check number of satellites */
 if (gps.satellites.isValid() == true) /* Valid GPS number of satellites received ? */
 {
 NO_OF_SAT = gps.satellites.value(); /* Save number of satellites */ 
 }
 else /* Not valid GPS number of satellites received ? */
 {
 NO_OF_SAT = 0; /* Set number of satellites to 0 */
 }
 /* Decide on number of satellites received */
 if (NO_OF_SAT < MINUMUM_SAT) /* Too less satelites received ? */
 {
 if (UPDATE_FLAG == true) /* Update flag true ? */
 {
 SUB_DISPLAY_NO_GPS(); /* Call sub routine to display no GPS message */ 
 UPDATE_FLAG = false; /* Set update flag false */
 } 
 }
 else /* Correct number of satellites received? */
 {
 GPS_STATUS = 2; /* Set GPS status 2 --> Fix received */
 UPDATE_FLAG = true; /* Set update flag true */
 UPDATE_FLAG = true; /* Set display update flag true */
 LOC_UPDATE_FLAG = true; /* Set location update flag true */ 
 ALT_UPDATE_FLAG = true; /* Set altitude update flag true */
 SPEED_UPDATE_FLAG = true; /* Set speed update flag true */
 SAT_UPDATE_FLAG = true; /* Set number of sattelites update flag true */
 HDOP_UPDATE_FLAG = true; /* Set HDOP update flag true */
 } 
 }

 /* Case 2: Enough satellites received ? --> Valid fix*/
 if (GPS_STATUS == 2) /* GPS status is 2 ? */ 
 {
 /* Check number of satellites */
 if (gps.satellites.isValid() == true) /* Valid GPS number of sattllites received ? */
 {
 NO_OF_SAT = gps.satellites.value(); /* Save number of satellites */ 
 }
 else /* Not valid GPS number of sattelites received ? */
 {
 NO_OF_SAT = 0; /* Set number of satellites to 0 */
 }
 if (NO_OF_SAT < MINUMUM_SAT) /* Too less satelites received ? */
 { 
 GPS_STATUS = 1; /* Set GPS status 1 */
 UPDATE_FLAG = true; /* Set update flag true */
 } 
 else /* Correct number of satellites received? */
 {
 if (UPDATE_FLAG == true) /* Update flag true ? */
 {
 SUB_DISPLAY_MAIN(); /* Call sub routine to display main menu */ 
 UPDATE_FLAG = false; /* Set update flag false */
 } 
 
 SUB_DISPLAY_DATE_TIME(); /* Call sub routine to display time and date info */
 SUB_DISPLAY_LOCATION(); /* Call sub routine to display location */
 SUB_DISPLAY_ALTITUDE(); /* Call sub routine to display altitude */
 SUB_DISPLAY_SPEED(); /* Call sub routine to display speed */
 SUB_DISPLAY_SAT(); /* Call sub routine to display number of sattelites */
 SUB_DISPLAY_HDOP(); /* Call sub routine to display HDOP value */
 }
 } 

 OLD_CHARS_PROCESSED = CHARS_PROCESSED;

 /* Delay as defined in delay read const and check on key pressed every 10ms */
 for (LOOP_COUNTER = 0; LOOP_COUNTER < DELAY_READ; LOOP_COUNTER++)
 {
 delay (10); /* 10 ms delay */
 M5.update(); /* Update on reading keys */

 if (M5.BtnA.wasPressed() == true) /* Button A pressed ? --> Change language */
 {
 // M5.Speaker.tone(NOTE_DH2, 1); 
 if (MENU_LANGUAGE == 0) /* German selected ? */
 {
 MENU_LANGUAGE = 1; /* Set menu language to English */
 UPDATE_FLAG = true; /* Set display update flag true */
 LOC_UPDATE_FLAG = true; /* Set location update flag true */ 
 ALT_UPDATE_FLAG = true; /* Set altitude update flag true */
 SPEED_UPDATE_FLAG = true; /* Set speed update flag true */
 SAT_UPDATE_FLAG = true; /* Set number of sattelites update flag true */
 HDOP_UPDATE_FLAG = true; /* Set HDOP update flag true */
 }
 else /* English selected ? */
 {
 MENU_LANGUAGE = 0; /* Set menu language to German */
 UPDATE_FLAG = true; /* Set display update flag true */
 LOC_UPDATE_FLAG = true; /* Set location update flag true */ 
 ALT_UPDATE_FLAG = true; /* Set altitude update flag true */
 SPEED_UPDATE_FLAG = true; /* Set speed update flag true */
 SAT_UPDATE_FLAG = true; /* Set number of sattelites update flag true */
 HDOP_UPDATE_FLAG = true; /* Set HDOP update flag true */
 }
 }

 if (M5.BtnB.wasPressed() == true) /* Button B pressed ? --> Change format */
 {
 // M5.Speaker.tone(NOTE_DH2, 1); 
 if (GPS_FORMAT == 0) /* Format 0 selected ? */
 {
 GPS_FORMAT = 1; /* Set Format to 1 */
 LOC_UPDATE_FLAG = true; /* Set location update flag true */
 }
 else /* Format 1 selected ? */
 {
 GPS_FORMAT = 0; /* Set Format to 0 */
 LOC_UPDATE_FLAG = true; /* Set location update flag true */
 }
 }
 
 if (M5.BtnC.wasPressed() == true) /* Button C pressed ? --> Change brightness */
 {
// M5.Speaker.tone(NOTE_DH2, 1); 
 if (LCD_BRIGHTNESS < 250) /* Maximum brightness not reached ? */
 {
 LCD_BRIGHTNESS = LCD_BRIGHTNESS + 10; /* Increase brightness */
 }
 else /* Maximum brightness reached ? */
 {
 LCD_BRIGHTNESS = 10; /* Set brightness to lowest value */
 }
 M5.Lcd.setBrightness(LCD_BRIGHTNESS); /* Change brightness value */
 }
 }
}

/****************************************************************************************/
/* SUBROUTINE Display Date and Time Information */
/* This subroutine displays the time and date information and corrects the time zone */
/****************************************************************************************/
void SUB_DISPLAY_DATE_TIME ()
{
 boolean TIME_VALID; /* True = Valid time, False = not valid */
 boolean DATE_VALID; /* True = Valid date, False = not valid */
 boolean TIME_DATE_UPDATE; /* True = Needs update, False = Needs no update */
 byte NTP_TIME_ZONE; /* Variable for time zone: 0 = UTC time, 1 = CET winter time, 2 = CET summer time */
 int BEGIN_DST_DATE; /* Begin date summer time */
 int BEGIN_DST_MONTH; /* Begin month summer time */
 int END_DST_DATE; /* End date summer time */
 int END_DST_MONTH; /* End month summer time */
 int ACT_YEAR; /* Actual year */ 
 int ACT_MONTH; /* Actual month */ 
 int ACT_DAY; /* Actual day */ 
 int ACT_HOUR; /* Actual hour */ 
 int ACT_MIN; /* Actual minute */ 
 int ACT_SEC; /* Actual second */

 TIME_DATE_UPDATE = false; /* No update needed */
 
 if (gps.time.isValid()) /* Valid time available ? */
 {
 ACT_HOUR = gps.time.hour(); /* Get actual hour */
 ACT_MIN = gps.time.minute(); /* Get actual minute */
 ACT_SEC = gps.time.second(); /* Get actual second */
 TIME_VALID = true; /* Set valid time flag true */
 TIME_DATE_UPDATE = true; /* Update needed */
 } 
 else /* Valid time not available ? */
 {
 TIME_VALID = false; /* Set valid time flag false */
 }

 if (gps.date.isValid()) /* Valid date available ? */
 {
 ACT_YEAR = gps.date.year(); /* Get actual year */
 ACT_MONTH = gps.date.month(); /* Get actual month */ 
 ACT_DAY = gps.date.day(); /* Get actual day */
 DATE_VALID = true; /* Set valid time flag true */
 TIME_DATE_UPDATE = true; /* Update needed */
 } 
 else /* Valid time not available ? */
 {
 DATE_VALID = false; /* Set valid date flag false */
 }

 /* Changed second and valid date/time --> Update display */
 if ((OLD_SEC != ACT_SEC) && (TIME_VALID == true) && (DATE_VALID == true))
 {
 OLD_SEC = ACT_SEC; /* Save old second */

 /* Step 1: Leap year? --> Adjust February */
 if (ACT_YEAR%400 == 0 || (ACT_YEAR%4 == 0 && ACT_YEAR%100 !=0))
 {
 DAY_OF_MONTH[1] = 29; /* Set day of month to 29 */
 }
 else 
 { 
 DAY_OF_MONTH[1] = 28; /* Set day of month to 28 */
 }

 /* Step 2: Determine start and end date of summer time */
 BEGIN_DST_DATE= (31 - (5* ACT_YEAR /4 + 4) % 7); /* Determine last Sunday of March */
 BEGIN_DST_MONTH = 3; /* Begin month is March */
 END_DST_DATE= (31 - (5 * ACT_YEAR /4 + 1) % 7); /* Determine last Sunday of October */
 END_DST_MONTH = 10; /* Begin month is October */
 
 /* Step 3: Check for summer time */
 if (((ACT_MONTH > BEGIN_DST_MONTH) && (ACT_MONTH < END_DST_MONTH))
 || ((ACT_MONTH == BEGIN_DST_MONTH) && (ACT_DAY >= BEGIN_DST_DATE))
 || ((ACT_MONTH == END_DST_MONTH) && (ACT_DAY <= END_DST_DATE)))
 {
 NTP_TIME_ZONE = UTC_CET; /* Set time zone for CET = UTC + 2 hour */
 }
 else /* Winter time ? */
 {
 NTP_TIME_ZONE = UTC_CET-1; /* Set time zone for CET = UTC +1 hour */
 }

 /* Step 4: Generate correct adjusted time */
 ACT_HOUR = ACT_HOUR + NTP_TIME_ZONE; 
 if (ACT_HOUR > 23) /* Next day ? */
 {
 ACT_HOUR = ACT_HOUR - 23; /* Correct hour */
 if (ACT_DAY = DAY_OF_MONTH [ACT_MONTH-1]) /* Last day of month ? */
 {
 ACT_DAY = 1; /* Set day to 1st of month */
 ACT_MONTH = ACT_MONTH +1; /* Increase month */
 if (ACT_MONTH > 12) /* Beyond December ? */
 {
 ACT_MONTH = 1; /* Set actual month to January */
 ACT_YEAR = ACT_YEAR + 1; /* Increase year */
 }
 }
 }
 
 /* Step 4: Display actual time and date according chosen language */
 M5.Lcd.fillRect(0, 215, 320, 25, 0x439); /* Clear old time and date */
 M5.Lcd.setTextSize(2); /* Set text size to 2 */
 M5.Lcd.setCursor(10, 219); /* Position cursor to display time */ 
 /* Convert into dispaly string */
 sprintf(CONVERTED, "%02d:%02d:%02d ", ACT_HOUR, ACT_MIN, ACT_SEC);
 M5.Lcd.print(CONVERTED); /* Display converted time string */
 M5.Lcd.setCursor(190, 219); /* Position cursor to display date */
 if (MENU_LANGUAGE == 0) /* German language chosen ? */
 { 
 /* Convert into dispaly string */
 sprintf(CONVERTED, "%02d.%02d.%02d ", ACT_DAY, ACT_MONTH, ACT_YEAR);
 }
 else /*Englishn language chosen ? */ 
 {
 /* Convert into dispaly string */
 sprintf(CONVERTED, "%02d/%02d/%02d ", ACT_YEAR, ACT_MONTH, ACT_DAY);
 }
 M5.Lcd.print(CONVERTED); /* Display converted date string */
 }

 /* Time or date not correctly received */
 if ((TIME_VALID == false) || (DATE_VALID == false))
 {
 if (TIME_DATE_UPDATE == true) /* Update needed ? */
 {
 M5.Lcd.fillRect(0, 215, 320, 25, 0x439); /* Clear old time and date */
 M5.Lcd.setTextSize(2); /* Set text size to 2 */
 M5.Lcd.print(F("--:--:--")); /* Dispaly time placeholder */
 M5.Lcd.setCursor(190, 219); /* Position cursor to display date */
 if (MENU_LANGUAGE == 0) /* German language chosen ? */
 {
 M5.Lcd.print(F("--.--.----")); /* Display date placeholder */
 } 
 else /*Englishn language chosen ? */ 
 {
 M5.Lcd.print(F("----/--/--")); /* Display date placeholder */
 }
 TIME_DATE_UPDATE = false; /* Set date update false */
 }
 }
}

/****************************************************************************************/
/* SUBROUTINE Display Location */
/* This subroutine displays the location information */
/****************************************************************************************/
void SUB_DISPLAY_LOCATION ()
{
 boolean LOC_FAIL_UPDATE; /* True = Needs update, False = Needs no update */
 float ACT_LOC_LAT; /* Actual lateral location */ 
 float ACT_LOC_LNG; /* Actual longitudinal location */
 float ROUNDED_VAL; /* Rounded floating value */
 uint16_t CONVERT_DATA; /* Converted data value */

 LOC_FAIL_UPDATE = false; /* No update needed */
 
 if (gps.location.isValid() == true) /* Valid GPS location received ? */
 {
 LOC_FAIL_UPDATE = true; /* Update needed */
 M5.Lcd.setTextSize(3); /* Set text size to 3 */
 ACT_LOC_LAT = gps.location.lat(); /* Get lattitude value */
 ACT_LOC_LNG = gps.location.lng(); /* Get longitude value */

 /* Display lattitude value */
 ROUNDED_VAL = SUB_ROUND_FLOAT_VALUE (ACT_LOC_LAT, 5); /* Call subroutine to round float to 5 digits */
 /* Value has changed for updating display or location update flag true? */
 if ((OLD_LOC_LAT != ROUNDED_VAL) || (LOC_UPDATE_FLAG == true)) 
 {
 OLD_LOC_LAT = ROUNDED_VAL; /* Save value */
 M5.Lcd.fillRect(114, 40, 169, 44, 0x1E9F); /* Clear old degree of lattitude value */
 M5.Lcd.setCursor(115, 50); /* Position cursor */
 if (GPS_FORMAT == 0) /* Format 0 selected */
 { 
 M5.Lcd.print(ACT_LOC_LAT, 6); /* Display latitude information */
 }
 else /* Format 1 selected */
 {
 CONVERT_DATA = (int)(ACT_LOC_LAT); /* Extract degree value */
 M5.Lcd.print(CONVERT_DATA); /* Display degree value */
 M5.Lcd.print(" ");
 /* Extract Minute value */
 ACT_LOC_LAT= ACT_LOC_LAT - CONVERT_DATA;
 ACT_LOC_LAT = ACT_LOC_LAT * 60; 
 CONVERT_DATA = (int)(ACT_LOC_LAT);
 M5.Lcd.print(CONVERT_DATA); /* Display minute value */
 M5.Lcd.print(" ");
 /*Extract Second value */
 ACT_LOC_LAT= ACT_LOC_LAT - CONVERT_DATA;
 ACT_LOC_LAT = ACT_LOC_LAT * 60; 
 M5.Lcd.print (ACT_LOC_LAT, 0); /* Dispaly second value */
 }
 }
 
 /* Display lngitude value */
 ROUNDED_VAL = SUB_ROUND_FLOAT_VALUE (ACT_LOC_LNG, 5); /* Call subroutine to round float to 5 digits */
 /* Value has changed for updating display or location update flag true? */
 if ((OLD_LOC_LNG != ROUNDED_VAL) || (LOC_UPDATE_FLAG == true))
 {
 OLD_LOC_LNG = ROUNDED_VAL; /* Save value */
 M5.Lcd.fillRect(114, 94, 169, 44, 0x1E9F); /* Clear old degree of longitude value */
 M5.Lcd.setCursor(115, 104); /* Position cursor */
 if (GPS_FORMAT == 0) /* Format 0 selected */
 { 
 M5.Lcd.print(ACT_LOC_LNG, 6); /* Display longitudinal information */
 }
 else /* Format 1 selected */
 {
 CONVERT_DATA = (int)(ACT_LOC_LNG); /* Extract degree value */
 M5.Lcd.print(CONVERT_DATA); /* Display degree value */
 M5.Lcd.print(" ");
 /* Extract Minute value */
 ACT_LOC_LNG= ACT_LOC_LNG - CONVERT_DATA;
 ACT_LOC_LNG = ACT_LOC_LNG * 60; 
 CONVERT_DATA = (int)(ACT_LOC_LNG);
 M5.Lcd.print(CONVERT_DATA); /* Display minute value */
 M5.Lcd.print(" ");
 /*Extract Second value */
 ACT_LOC_LNG= ACT_LOC_LNG - CONVERT_DATA;
 ACT_LOC_LNG = ACT_LOC_LNG * 60; 
 M5.Lcd.print (ACT_LOC_LNG, 0); /* Dispaly second value */
 }
 }
 LOC_UPDATE_FLAG = false; /* Set location update flag false */
 }
 else /* Not valid GPS location received ? */ 
 {
 if (LOC_FAIL_UPDATE == true) /* Update needed ? */
 { 
 M5.Lcd.setTextSize(3);
 M5.Lcd.fillRect(114, 40, 169, 44, 0x1E9F); /* Clear old degree of lattitude value */
 M5.Lcd.fillRect(114, 94, 169, 44, 0x1E9F); /* Clear old degree of longitude value */
 if (GPS_FORMAT == 0) /* Format 0 selected */
 {
 M5.Lcd.setCursor(115, 50); /* Display location placeholder */
 M5.Lcd.print("--.------");
 M5.Lcd.setCursor(115, 104);
 M5.Lcd.print("--.------");
 }
 else /* Format 1 selected */
 {
 M5.Lcd.setCursor(115, 50); /* Display location placeholder */
 M5.Lcd.print("----'---");
 M5.Lcd.setCursor(115, 104);
 M5.Lcd.print("----'---");
 } 
 }
 LOC_FAIL_UPDATE = false; /* Set date update false */
 }
}

/****************************************************************************************/
/* SUBROUTINE Display Altitude */
/* This subroutine displays the altitude information */
/****************************************************************************************/
void SUB_DISPLAY_ALTITUDE ()
{
 boolean ALT_FAIL_UPDATE; /* True = Needs update, False = Needs no update */
 float ACT_ALTITUDE; /* Actual laltitude value */ 
 int INTEGER_VAL; /* Integer value */
 int STRING_LENGTH; /* Length of string */

 ALT_FAIL_UPDATE = false; /* No update needed */
 
 if (gps.altitude.isValid() == true) /* Valid GPS altitude received ? */
 {
 ALT_FAIL_UPDATE = true; /* Update needed */
 M5.Lcd.setTextSize(3); /* Set text size to 3 */
 ACT_ALTITUDE = gps.altitude.meters(); /* Get altitude value */

 /* Display altitude value */
 INTEGER_VAL = (int)(ACT_ALTITUDE); /* Extract integer value of altitude variable */
 sprintf(CONVERTED, "%.0f", ACT_ALTITUDE); /* Convert float to a string to determine length */
 STRING_LENGTH = strlen(CONVERTED); /* Determine length of string */
 /* Value has changed for updating display or location update flag true? */
 if ((OLD_ALTITUDE != INTEGER_VAL) || (ALT_UPDATE_FLAG == true)) 
 {
 OLD_ALTITUDE = INTEGER_VAL; /* Save value */
 M5.Lcd.fillRect(4, 145, 100, 40, 0x1E9F); /* Clear old altitude value */
 if (STRING_LENGTH >= 4) /* String length >= 4 ? */
 M5.Lcd.setCursor(8, 155); /* Position cursor */
 if (STRING_LENGTH == 3) /* String length = 3 ? */
 M5.Lcd.setCursor(18, 155); /* Position cursor */
 if (STRING_LENGTH == 2) /* String length = 2 ? */
 M5.Lcd.setCursor(25, 155); /* Position cursor */
 if (STRING_LENGTH<= 1) /* String length <= 1 ? */ 
 M5.Lcd.setCursor(35, 155); /* Position cursor */ 
 M5.Lcd.print(CONVERTED); /* Display value */
 M5.Lcd.print("m");
 } 
 ALT_UPDATE_FLAG = false; /* Set altitrude update flag false */ 
 }
 else /* Not valid GPS altitude received ? */
 {
 if (ALT_FAIL_UPDATE == true) /* Update needed ? */
 { 
 M5.Lcd.setTextSize(3); /* Set text size to 3 */
 M5.Lcd.fillRect(4, 145, 100, 40, 0x1E9F); /* Clear old altitude value */
 M5.Lcd.setCursor(18, 155); /* Position cursor */ 
 M5.Lcd.print("---m"); /* Display altitude placeholder */
 }
 ALT_FAIL_UPDATE = false; /* Set altitude update false */
 }
}

/****************************************************************************************/
/* SUBROUTINE Display Speed */
/* This subroutine displays the speed information */
/****************************************************************************************/
void SUB_DISPLAY_SPEED ()
{
 boolean SPEED_FAIL_UPDATE; /* True = Needs update, False = Needs no update */
 float ACT_SPEED; /* Actual speed value */ 
 int INTEGER_VAL; /* Integer value */
 int STRING_LENGTH; /* Length of string */

 SPEED_FAIL_UPDATE = false; /* No update needed */
 
 if (gps.speed.isValid() == true) /* Valid GPS speed received ? */
 {
 SPEED_FAIL_UPDATE = true; /* Update needed */
 M5.Lcd.setTextSize(3); /* Set text size to 3 */
 ACT_SPEED = gps.speed.kmph(); /* Get speed value */

 /* Display speed value */
 INTEGER_VAL = (int)(ACT_SPEED); /* Extract integer value of speed variable */
 sprintf(CONVERTED, "%.0f", ACT_SPEED); /* Convert float to a string to determine length */
 STRING_LENGTH = strlen(CONVERTED); /* Determine length of string */
 /* Value has changed for updating display or location update flag true? */
 if ((OLD_SPEED != INTEGER_VAL) || (SPEED_UPDATE_FLAG == true)) 
 {
 OLD_SPEED = INTEGER_VAL; /* Save value */
 M5.Lcd.fillRect(114, 145, 94, 40, 0x1E9F); /* Clear old speed value */
 if (STRING_LENGTH >= 4) /* String length >= 4 ? */
 M5.Lcd.setCursor(125, 155); /* Position cursor */
 if (STRING_LENGTH == 3) /* String length = 3 ? */
 M5.Lcd.setCursor(135, 155); /* Position cursor */
 if (STRING_LENGTH == 2) /* String length = 2 ? */
 M5.Lcd.setCursor(142, 155); /* Position cursor */
 if (STRING_LENGTH<= 1) /* String length <= 1 ? */ 
 M5.Lcd.setCursor(152, 155); /* Position cursor */ 
 M5.Lcd.print(CONVERTED); /* Display value */
 } 
 SPEED_UPDATE_FLAG = false; /* Set speed update flag false */ 
 }
 else /* Not valid GPS altitude received ? */
 {
 if (SPEED_FAIL_UPDATE == true) /* Update needed ? */
 { 
 M5.Lcd.setTextSize(3); /* Set text size to 3 */
 M5.Lcd.fillRect(114, 145, 94, 40, 0x1E9F); /* Clear old speed value */
 M5.Lcd.setCursor(135, 155); /* Position cursor */ 
 M5.Lcd.print("---"); /* Display speed placeholder */
 }
 SPEED_FAIL_UPDATE = false; /* Set speed update false */
 }
}

/****************************************************************************************/
/* SUBROUTINE Display Sattelites */
/* This subroutine displays the number of sattelites */
/****************************************************************************************/
void SUB_DISPLAY_SAT ()
{
 boolean SAT_FAIL_UPDATE; /* True = Needs update, False = Needs no update */

 SAT_FAIL_UPDATE = false; /* No update needed */

 if (gps.satellites.isValid() == true) /* Valid GPS number of sattllites received ? */
 {
 SAT_FAIL_UPDATE = true; /* Update needed */
 M5.Lcd.setTextSize(2); /* Set text size to 2 */
 /* Value has changed for updating display or location update flag true? */
 if ((OLD_NO_OF_SAT != NO_OF_SAT) || (SAT_UPDATE_FLAG == true)) 
 {
 OLD_NO_OF_SAT = NO_OF_SAT; /* Save value */
 M5.Lcd.fillRect(275, 145, 45, 35, 0x1E9F); /* Clear satelite field */
 M5.Lcd.setCursor(280, 155); /* Display header info */
 M5.Lcd.print(NO_OF_SAT); /* Display number of sattelites */ 
 }
 SAT_UPDATE_FLAG = false; /* Set speed update flag false */ 
 }
 else /* Not valid GPS altitude received ? */
 {
 if (SAT_FAIL_UPDATE == true) /* Update needed ? */
 { 
 M5.Lcd.fillRect(275, 145, 45, 35, 0x1E9F); /* Clear satelite field */
 M5.Lcd.setCursor(280, 155); /* Display header info */
 M5.Lcd.print("-"); /* Display sattelite placeholder */
 }
 SAT_FAIL_UPDATE = false; /* Set sattelite update false */
 }
}

/****************************************************************************************/
/* SUBROUTINE Display HDOP */
/* This subroutine displays the HDOP value */
/****************************************************************************************/
void SUB_DISPLAY_HDOP ()
{
 boolean HDOP_FAIL_UPDATE; /* True = Needs update, False = Needs no update */
 float ACT_HDOP; /* Actual HDOP value */
 unsigned int INTEGER_VAL; /* Integer value */

 HDOP_FAIL_UPDATE = false; /* No update needed */

 if (gps.hdop.isValid() == true) /* Valid GPS HDOP value received ? */
 {
 HDOP_FAIL_UPDATE = true; /* Update needed */
 M5.Lcd.setTextSize(2); /* Set text size to 2 */
 ACT_HDOP = gps.hdop.hdop(); /* Get HDOP value */
 INTEGER_VAL = (int)(ACT_HDOP); /* Extract integer value of HDOP variable */
 /* Value has changed for updating display or location update flag true? */
 if ((OLD_HDOP != INTEGER_VAL) || (HDOP_UPDATE_FLAG == true)) 
 {
 OLD_HDOP = INTEGER_VAL; /* Save value */
 M5.Lcd.fillRect(275, 180, 45, 28, 0x1E9F); /* Clear satelite field */
 M5.Lcd.setCursor(280, 185); /* Display header info */
 M5.Lcd.print(INTEGER_VAL); /* Display HDOP value */ 
 }
 HDOP_UPDATE_FLAG = false; /* Set HDOP update flag false */ 
 }
 else /* Not valid GPS altitude received ? */
 {
 if (HDOP_FAIL_UPDATE == true) /* Update needed ? */
 { 
 M5.Lcd.fillRect(275, 180, 45, 28, 0x1E9F); /* Clear satelite field */
 M5.Lcd.setCursor(280, 185); /* Display header info */
 M5.Lcd.print("---"); /* Display sattelite placeholder */
 }
 HDOP_FAIL_UPDATE = false; /* Set sattelite update false */
 }
} 

/****************************************************************************************/
/* SUBROUTINE Display Main */
/* This subroutine displays the main menu based on the selected kanguage */
/****************************************************************************************/
void SUB_DISPLAY_MAIN (void)
{ 
 M5.Lcd.fillRect(0, 0, 320, 30, 0x439); /* Upper dark blue area */
 M5.Lcd.fillRect(0, 31, 320, 178, 0x1E9F); /* Main light blue area */
 M5.Lcd.fillRect(0, 210, 320, 30, 0x439); /* Lower dark blue area */
 M5.Lcd.fillRect(0, 30, 320, 4, 0xffff); /* Upper white line */
 M5.Lcd.fillRect(0, 208, 320, 4, 0xffff); /* Lower white line */
 M5.Lcd.fillRect(0, 84, 320, 4, 0xffff); /* First vertical white line */
 M5.Lcd.fillRect(0, 140, 320, 4, 0xffff); /* Second vertical white line */
 M5.Lcd.fillRect(106, 140, 4, 72, 0xffff); /* First horizontal white line */
 M5.Lcd.fillRect(210, 140, 4, 72, 0xffff); /* First horizontal white line */
 M5.Lcd.setTextSize(2); /* Set text size to 2 */
 M5.Lcd.setTextColor(WHITE); /* Set text color to white */
 M5.Lcd.setCursor(10, 7); /* Display header info */
 M5.Lcd.print("GPS Logger");
 M5.Lcd.setCursor(210, 7);
 M5.Lcd.print("@PT 2019");

 if (MENU_LANGUAGE == 0) /* German language chosen ? */
 {
 M5.Lcd.setCursor(5, 40); /* Display degree of lattitude */
 M5.Lcd.print("Breiten-");
 M5.Lcd.setCursor(5, 65); 
 M5.Lcd.print("grad");
 M5.Lcd.setCursor(5, 94); /* Display degree of longitude */
 M5.Lcd.print("Laengen-");
 M5.Lcd.setCursor(5, 119); 
 M5.Lcd.print("grad");
 M5.Lcd.setCursor(25, 185); /* Display elevation info */
 M5.Lcd.print("Hoehe");
 M5.Lcd.setCursor(125, 185); /* Display hspeed info */
 M5.Lcd.print("Gesch.");
 }
 else /*Englishn language chosen ? */ 
 {
 M5.Lcd.setCursor(5, 40); /* Display degree of lattitude */
 M5.Lcd.print("Degree");
 M5.Lcd.setCursor(5, 65); 
 M5.Lcd.print("of Lat.");
 M5.Lcd.setCursor(5, 94); /* Display degree of longitude */
 M5.Lcd.print("Degree");
 M5.Lcd.setCursor(5, 119); 
 M5.Lcd.print("of Long.");
 M5.Lcd.setCursor(25, 185); /* Display altitude info */
 M5.Lcd.print("Alti.");
 M5.Lcd.setCursor(125, 185); /* Display hspeed info */
 M5.Lcd.print("Speed");
 }
 
 M5.Lcd.setCursor(215, 155); /* Display number of sattelites */
 M5.Lcd.println(" Sat.");
 M5.Lcd.setCursor(215, 185); /* Display HDOP info */
 M5.Lcd.print(" HDOP");
 M5.Lcd.setTextSize(3); /* Set text size to 3 */
 M5.Lcd.setCursor(295, 50); /* Display North info */
 M5.Lcd.print("N");
 if (MENU_LANGUAGE == 0) /* German language chosen ? */
 { 
 M5.Lcd.setCursor(295, 104); /* Display East info */
 M5.Lcd.print("O");
 }
 else /* Englishn language chosen ? */ 
 {
 M5.Lcd.setCursor(295, 104); /* Display East info */
 M5.Lcd.print("E");
 }
}

/****************************************************************************************/
/* SUBROUTINE No receiver */
/* This subroutine displays the screen when no GPS receiver is found */
/****************************************************************************************/
void SUB_DISPLAY_NO_REC (void)
{ 
 M5.Lcd.fillRect(0, 0, 320, 30, 0x439); /* Upper dark blue area */
 M5.Lcd.fillRect(0, 31, 320, 178, 0x1E9F); /* Main light blue area */
 M5.Lcd.fillRect(0, 210, 320, 30, 0x439); /* Lower dark blue area */ 
 M5.Lcd.setTextSize(3); /* Set text size to 3 */
 M5.Lcd.setTextColor(WHITE); /* Set text color to white */
 if (MENU_LANGUAGE == 0) /* German language chosen ? */
 { 
 M5.Lcd.setCursor(80, 80); /* Display message */
 M5.Lcd.print(F("Kein GPS!"));
 M5.Lcd.setCursor(40, 120);
 M5.Lcd.print(F("Pruefe Modul!"));
 }
 else /* Englishn language chosen ? */ 
 { 
 M5.Lcd.setCursor(100, 80); /* Display message */
 M5.Lcd.print(F("No GPS!"));
 M5.Lcd.setCursor(40, 120);
 M5.Lcd.print(F("Check module!")); 
 }
}

/****************************************************************************************/
/* SUBROUTINE No GPS signal */
/* This subroutine displays the screen when no or a weak GPS signal is available */
/****************************************************************************************/
void SUB_DISPLAY_NO_GPS (void)
{ 
 M5.Lcd.fillRect(0, 0, 320, 30, 0x439); /* Upper dark blue area */
 M5.Lcd.fillRect(0, 31, 320, 178, 0x1E9F); /* Main light blue area */
 M5.Lcd.fillRect(0, 210, 320, 30, 0x439); /* Lower dark blue area */ 
 M5.Lcd.setTextSize(3); /* Set text size to 3 */
 M5.Lcd.setTextColor(WHITE); /* Set text color to white */
 if (MENU_LANGUAGE == 0) /* German language chosen ? */
 { 
 M5.Lcd.setCursor(40, 80); /* Display message */
 M5.Lcd.print(F("Kein valides"));
 M5.Lcd.setCursor(50, 120);
 M5.Lcd.print(F("GPS Signal!"));
 }
 else /* Englishn language chosen ? */ 
 { 
 M5.Lcd.setCursor(70, 80); /* Display message */
 M5.Lcd.print(F("No valid"));
 M5.Lcd.setCursor(50, 120);
 M5.Lcd.print(F("GPS signal!")); 
 }
}

/****************************************************************************************/
/* SUBROUTINE to round floating value */
/* Input to this subroutine is float value amd number of digits after decimal point */
/****************************************************************************************/
float SUB_ROUND_FLOAT_VALUE (float FLOAT_IN, byte DIGITS) 
{
 float SHIFTS = 1; /* Define shift value */
 while (DIGITS--) /* Process until digit value is zero */
 {
 SHIFTS *= 10; /* Increase shifts value */
 }
 return floor(FLOAT_IN * SHIFTS + .5) / SHIFTS; /* Calculated rounded value */
}

Programme Température - Humidité
#include <Arduino.h>
#include <M5Stack.h>
#include <Wire.h>
#include "SHT31.h"
#include "Free_Fonts.h" 

SHT31 sht31 = SHT31();
 
void setup() { 
 Serial.begin(9600);
 while(!Serial);
 Serial.println("begin..."); 
 sht31.begin(); 
 M5.begin(); // Init M5Core. 初始化 M5Core
 M5.Power.begin(); // Init Power module. 初始化电源模块
 
}
 
void loop() {
 float temp = sht31.getTemperature();
 float hum = sht31.getHumidity();

 M5.Lcd.fillRect(0, 0, 320, 30, 0x439); /* Upper dark blue area */
 M5.Lcd.fillRect(0, 31, 320, 178, 0x1E9F); /* Main light blue area */
 M5.Lcd.fillRect(0, 210, 320, 30, 0x439); /* Lower dark blue area */
 M5.Lcd.fillRect(0, 30, 320, 4, 0xffff); /* Upper white line */
 M5.Lcd.fillRect(0, 208, 320, 4, 0xffff); /* Lower white line */
 M5.Lcd.fillRect(0, 125, 160, 4, 0xffff); /* vertical white line */
 M5.Lcd.fillRect(160, 30, 4, 180, 0xffff); /* Horizontal white line */

 M5.Lcd.setTextSize(2); /* Set text size to 2 */
 M5.Lcd.setTextColor(WHITE); /* Set text color to white */
 M5.Lcd.setCursor(10, 7); /* Display header info */
 M5.Lcd.print("Weather");
 M5.Lcd.setCursor(200, 7);
 M5.Lcd.print("Analyz'Air");
 M5.Lcd.setTextSize(2.5); M5.lcd.setCursor(12.5,40);
 M5.Lcd.print("Temperature: ");
 M5.Lcd.setTextSize(4); M5.lcd.setCursor(15,70);
 M5.Lcd.print(temp);
 M5.Lcd.setTextSize(3); M5.lcd.setCursor(140,75); M5.Lcd.println("C");
 M5.Lcd.setTextSize(2.5); M5.lcd.setCursor(30,135);
 M5.Lcd.print("Humidity: ");
 M5.Lcd.setTextSize(4); M5.lcd.setCursor(15,165);
 M5.Lcd.print(hum);
 M5.Lcd.setTextSize(3); M5.lcd.setCursor(140,170); M5.Lcd.println("%");
 M5.Lcd.println(); 
 delay(2000);
}

Ce code a été obtenu grâce au Wiki Seeed Studio où est disponible le code de base. Puis nous l'avons modifié à notre guise afin d'afficher les valeurs sur le M5Stack grâce à la commande M5.Lcd.print, de modifier le design grâce aux commandes M5.Lcd.setTextSize et M5.Lcd.fillRect, et de placer les valeurs où on le souhaitait grâce à la commandes M5.setcursor. Une fois ces modifications faites, on obtient le code ci-dessus.

Programme Baromètre

#include <Dps310.h>

// Dps310 Opject
Dps310 Dps310PressureSensor = Dps310();

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

 //Call begin to initialize Dps310PressureSensor
 //The parameter 0x76 is the bus address. The default address is 0x77 and does not need to be given.
 //Dps310PressureSensor.begin(Wire, 0x76);
 //Use the commented line below instead to use the default I2C address.
 Dps310PressureSensor.begin(Wire);

 //temperature measure rate (value from 0 to 7)
 //2^temp_mr temperature measurement results per second
 int16_t temp_mr = 2;
 //temperature oversampling rate (value from 0 to 7)
 //2^temp_osr internal temperature measurements per result
 //A higher value increases precision
 int16_t temp_osr = 2;
 //pressure measure rate (value from 0 to 7)
 //2^prs_mr pressure measurement results per second
 int16_t prs_mr = 2;
 //pressure oversampling rate (value from 0 to 7)
 //2^prs_osr internal pressure measurements per result
 //A higher value increases precision
 int16_t prs_osr = 2;
 //startMeasureBothCont enables background mode
 //temperature and pressure ar measured automatically
 //High precision and hgh measure rates at the same time are not available.
 //Consult Datasheet (or trial and error) for more information
 int16_t ret = Dps310PressureSensor.startMeasureBothCont(temp_mr, temp_osr, prs_mr, prs_osr);
 //Use one of the commented lines below instead to measure only temperature or pressure
 //int16_t ret = Dps310PressureSensor.startMeasureTempCont(temp_mr, temp_osr);
 //int16_t ret = Dps310PressureSensor.startMeasurePressureCont(prs_mr, prs_osr);

 if (ret != 0) {
 Serial.print("Init FAILED! ret = ");
 Serial.println(ret);
 } else {
 Serial.println("Init complete!");
 }
}

void loop() {
 uint8_t pressureCount = 20;
 float pressure[pressureCount];
 uint8_t temperatureCount = 20;
 float temperature[temperatureCount];

 //This function writes the results of continuous measurements to the arrays given as parameters
 //The parameters temperatureCount and pressureCount should hold the sizes of the arrays temperature and pressure when the function is called
 //After the end of the function, temperatureCount and pressureCount hold the numbers of values written to the arrays
 //Note: The Dps310 cannot save more than 32 results. When its result buffer is full, it won't save any new measurement results
 int16_t ret = Dps310PressureSensor.getContResults(temperature, temperatureCount, pressure, pressureCount);

 if (ret != 0) {
 Serial.println();
 Serial.println();
 Serial.print("FAIL! ret = ");
 Serial.println(ret);
 } else {
 Serial.println();
 Serial.println();
 Serial.print(temperatureCount);
 Serial.println(" temperature values found: ");
 for (int16_t i = 0; i < temperatureCount; i++) {
 Serial.print(temperature[i]);
 Serial.println(" degrees of Celsius");
 }

 Serial.println();
 Serial.print(pressureCount);
 Serial.println(" pressure values found: ");
 for (int16_t i = 0; i < pressureCount; i++) {
 Serial.print(pressure[i]);
 Serial.println(" Pascal");
 }
 }

 //Wait some time, so that the Dps310 can refill its buffer
 delay(10000);
}

Les commandes Serial.print nous indiquent que les valeurs et les unités de la pression s'afficheront sur le serial monitor du logiciel arduino et non sur notre M5stack. Afin de les afficher sur le M5stack, nous remplacerons cette commande par la commande M5.Lcd.print afin de les afficher sur celui-ci. Cette commande est présente sur le code suivant contenant les codes servant à afficher la pression, l'humidité, et la température réunis. Il est présent dans l'onglet "Programme Météo Complet".

La prochaine étape sera de réunir ces trois codes différents afin de finaliser notre logiciel puis lorsque l'assemblage sera fini, réalisera le design extérieur.

Programme Météo complet
#include <Arduino.h>
#include <M5Stack.h>
#include <Wire.h>
#include "SHT31.h"
#include <Dps310.h>
#include "Free_Fonts.h" 

SHT31 sht31 = SHT31();
Dps310 Dps310PressureSensor = Dps310();
 
void setup() { 
 Serial.begin(9600);
 while(!Serial);
 Serial.println("begin..."); 
 sht31.begin(); 
 Dps310PressureSensor.begin(Wire);
 M5.begin(); // Init M5Core. 初始化 M5Core
 M5.Power.begin(); // Init Power module. 初始化电源模块
 
}
 
void loop(){
 mesure();
 M5.Lcd.fillRect(0, 0, 320, 30, 0x439); /* Upper dark blue area */
 M5.Lcd.fillRect(0, 31, 320, 178, 0x1E9F); /* Main light blue area */
 M5.Lcd.fillRect(0, 210, 320, 30, 0x439); /* Lower dark blue area */
 M5.Lcd.fillRect(0, 30, 320, 4, 0xffff); /* Upper white line */
 M5.Lcd.fillRect(0, 208, 320, 4, 0xffff); /* Lower white line */
 M5.Lcd.fillRect(0, 125, 160, 4, 0xffff); /* vertical white line */
 M5.Lcd.fillRect(160, 30, 4, 180, 0xffff); /* Horizontal white line */

 M5.Lcd.setTextSize(2); /* Set text size to 2 */
 M5.Lcd.setTextColor(WHITE); /* Set text color to white */
 M5.Lcd.setCursor(10, 7); /* Display header info */
 M5.Lcd.print("Weather");
 M5.Lcd.setCursor(200, 7);
 M5.Lcd.print("Analyz'Air");
}

void mesure() {

 float temp = sht31.getTemperature();
 float hum = sht31.getHumidity();
 float temperature;
 float pressure;
 uint8_t oversampling = 7;
 int16_t ret;

 M5.Lcd.println();

 

 ret = Dps310PressureSensor.measurePressureOnce(pressure, oversampling);
 if (ret != 0)
 {
 //Something went wrong.
 //Look at the library code for more information about return codes
 M5.Lcd.print("FAIL! ret = ");
 M5.Lcd.println(ret);
 }
 else
 {
 M5.Lcd.setTextSize(2.5); M5.lcd.setCursor(12.5,40);
 M5.Lcd.print("Temperature: ");
 M5.Lcd.setTextSize(4); M5.lcd.setCursor(15,70);
 M5.Lcd.print(temp);
 M5.Lcd.setTextSize(3); M5.lcd.setCursor(140,75); 
 M5.Lcd.println("C");
 M5.Lcd.setTextSize(2.5); M5.lcd.setCursor(30,135);
 M5.Lcd.print("Humidity: ");
 M5.Lcd.setTextSize(4); M5.lcd.setCursor(15,165);
 M5.Lcd.print(hum);
 M5.Lcd.setTextSize(3); M5.lcd.setCursor(140,170); 
 M5.Lcd.println("%");
 M5.Lcd.setTextSize(2.5); M5.lcd.setCursor(200,40);
 M5.Lcd.print("Pression: ");
 M5.Lcd.setTextSize(3); M5.lcd.setCursor(180,70);
 M5.Lcd.print(pressure);
 M5.Lcd.setTextSize(3); M5.lcd.setCursor(260,70); 
 M5.Lcd.println(" Pa ");
 }
 
 delay(2000);
}
Une fois les codes combinés, nous obtenons le code ci-dessus qui permettra d'afficher l'ensemble des informations météorologiques.

Voici le rendu une fois le programme terminé, de la station météorologique Analyz'Air :

             

Séance 9 à 10 : Projet Final - Création de la boite
Afin de finaliser notre station météorologique, nous devions créer une boite de transport pour notre m5stack ainsi que pour tous les composants électroniques.
Pour ce faire, nous avons utilisé le logiciel de modélisation 3D : Fusion 360.

Étape 1 : CRÉATION DE LA COQUE

Étape 2 : CRÉATION DE LA GRILLE DE FERMETURE ET DU SYSTEME DE VENTILLATION

Étape 3 : CRÉATION DU SYSTEME DE FERMETURE ET DU SYSTEME DE CLIPSAGE DE POIGNÉE

Étape 4 : CRÉATION DE LA POIGNÉE ET D'UNE PLAQUE PERMETTANT DE PLACER CORRECTEMENT DE M5STACK

Étape 5 : IMPRESSION 3D DE LA COQUE
Afin d'imprimer cette coque, nous avons utiliser les imprimantes 3D "Raise3D Pro" présentent au FabLab.
Lors de l'impression, nous avons utilisé du plastique PLA de couleur blanche afin de réfracté les rayons arrivant sur la boite afin d'éviter au maximum de chauffer l'intérieur pour ne pas biaiser les mesures.

Rendu Projet Finale
Montage du m5stack avec tous les capteurs :

Rendu du l'impression 3D de la coque :

Montage complet - m5stack + coque :
               

Fin de Projet

Fin du projet et de l’UE
En cette fin d’UE, nous avons présenté à l’oral au reste de la classe notre projet de station météo en retraçant notre démarche au long du semestre. Toutes ces séances au Fablab nous ont appris énormément : nous savons maintenant utiliser une carte Arduino ou un M5Stack et tous les capteurs qui y sont rattachés; utiliser une imprimante 3D de façon à avoir un résultat optimal; utiliser une découpeuse laser; documenter le mieux possible un projet pour qu’il devienne accessible pour tous; confectionner un objet électronique en équipe tout en respectant une limite de temps.

Lien vers notre présentation finale : Diaporama présnetation Analyz'air
Nous tenons à remercier l’équipe du Fablab pour son aide et le savoir faire qu’elle nous a transmis qui nous sera sans aucun doute très utile dans la suite de nos études.

Groupe A1 💡

Membres du groupe : Maxime ARRESSEGUET Sophie NAVARRO Malick DIALLO Paul SPIRCKEL

 

Séance 1 : 23/01/2023 -----------------------------------------------------
Découverte et émergence d'idées
Il s’agissait de la première séance consacrée au projet FabLab. Nous avons tous les 4 commencé à chercher des idées pour notre projet. Celui-ci doit comporter au moins 1 capteur mesurant un ou plusieurs élément(s) dans l’environnement qui nous entoure (température, pression, humidité, luminosité…) Nous souhaitons concevoir un objet qui ait une utilité (pour les étudiants par exemple). Afin d’éveiller notre imagination, nous avons exploré la liste des capteurs proposés par SeeedStudio (Grove - Seeed Studio).

Notre première idée est de concevoir un appareil capable de réaliser plusieurs étapes dans la cuisson d’aliments comme des pâtes, de manière automatique. Plus précisément, il s’agirait d’un appareil posé sur une casserole pleine d’eau, dans lequel se trouve des pâtes par exemple, il est équipé d’une “trappe” qui s’ouvre dès que l’eau bout (ce qui est mesuré à l’aide du thermomètre de l’appareil), ce dernier possède aussi une petite cuillère en bois, qui remue constamment les pâtes lorsqu’elles sont dans l’eau. Enfin, notre appareil enverra une notification ou sonnera une minute avant la fin de la cuisson.

Séance 2 : 15/02/2023 -----------------------------------------------------
Prise en main du logiciel ARDUINO
La séance d'aujourd'hui constituait en la prise en main du logiciel ARDUINO.

Nous avons découvert la carte arduino UNO.

Une fois que le logiciel est installé, il est possible de télécharger des croquis (sketches) pour contrôler les capteurs sur Arduino. Lors de notre séance nous avons utilisé les capteurs d'humidité et de température.
Les croquis pour utiliser les capteurs sur Arduino peuvent être trouvés en ligne sur des sites tels que GitHub. Ci dessous voici par exemple les croquis d'un composant Grove LCD RGB.

Les croquis sont généralement écrits en langage C et sont téléchargés sur la carte Arduino via le port USB de l'ordinateur.
Pour utiliser les croquis, il est important de comprendre le fonctionnement des capteurs et de choisir le bon croquis pour chaque capteur. Les croquis peuvent être modifiés pour adapter les capteurs aux besoins spécifiques du projet.

La prise en main comprenait notamment le codage des capteurs à notre disposition. Par exemple avec un capteur de température et un écran nous devions prendre en main les codes en C afin d'afficher les valeurs relevées par le capteur sur l'écran.

Voici par exemple le bricolage de code (langage C) que nous avons réussi à réaliser en peu de temps d'après les programmes examples fournis avec les library attachées aux capteurs :

#include <Wire.h>
#include "rgb_lcd.h"
#include <Arduino.h>
#include <Wire.h>
#include "SHT31.h"
 
SHT31 sht31 = SHT31();
 rgb_lcd lcd;
 
const int colorR = 200;
const int colorG = 100;
const int colorB = 100;
 
void setup() 
{
 // set up the LCD's number of columns and rows:
 sht31.begin();
 lcd.begin(16, 2);
 
 lcd.setRGB(colorR, colorG, colorB);
 
 delay(1000);
}
 
void loop() 
{
 // set the cursor to column 0, line 1
 // (note: line 1 is the second row, since counting begins with 0):
 lcd.setCursor(0, 0);
 
 float temp = sht31.getTemperature();
 lcd.print("Temp = ");
 lcd.print(temp);
 lcd.println(" C "); //The unit for Celsius because original arduino don't support speical symbols
 lcd.println(" ");
 
 lcd.setCursor(0, 1);
 float hum = sht31.getHumidity(); 
 lcd.print("Hum = ");
 lcd.print(hum);
 lcd.println(" % ");
 
}

Grâce auquel nous avons obtenu un résultat plutôt satisfaisant :

Découverte du M5Stack
La deuxième partie de la séance était consacrée à la prise en main d'une carte M5Stack (similaire à Arduino). Nous avons réalisé le même travail (affichage température et humidité en temps réel (pas d'images)).

Découverte pratique

Séance 3 : 17/02/2023 -----------------------------------------------------
Redéfinition du projet
Tout d'abord, nous avons redéfini notre projet pour cette UE. En effet, nous étions partis sur une idée de robot qui faciliterait la cuisson des pâtes ou du riz mais nous nous sommes assez vite rendus compte que ce dernier allait être trop compliqué à réaliser. Ainsi, notre nouvelle idée consiste à créer un robot qui fuit lorsqu'on s'approche de lui. Il sera équipé de capteurs de distance à l'avant, à l'arrière et sur les côtés qui lui permettront d'avancer lorsqu'il détecte quelque chose au niveau de ces capteurs. Il reculera lorsque quelque chose sera placé devant lui. Nous aimerions aussi pouvoir intégrer une fonction qui fera jouer de la musique à notre robot dès qu'il se déplace, pour "narguer" la personne qu'il fuit.

Découverte des outils de modélisation 2D & 3D
Lors de cette séance, nous avons appris à modéliser en 2D et en 3D à l'aide des logiciels Inkscape, FreeCad et OpenScad.

Sur OpenSCAD comme sur FreeCAD, un des exercices était de modéliser un cube troué sur chacune des faces. Ainsi nous avons pris en main plusieurs outils fondamentaux de ce type de logiciels : modéliser des formes simples, les déplacer dans l'espace, les recouper...

Sur OpenSCAD (fichier cubetrous.scad) :

Code C++ :
$fn=100;

module trous(){
 cylinder(51, 5, 5, center=true);
 rotate([0,90,0])cylinder(51, 5, 5, center=true);
 rotate([90,0,0])cylinder(51, 5, 5, center=true);
};

difference(){cube(50, center = true);
 trous();
 };
Rendu :

Sur FreeSCAD (fichier cubetrous.FCStd) :

Rendu :

Projets personnels
A l'issue de cette séance, nous devons chacun modéliser un objet 2D (InkScape) et 3D (OpenSCAD ou FreeCAD) :

Maxime
Projet 2D (InkScape) :
Pour ce projet, j'ai décidé de modéliser sur un carré de 10 cm, la texture d'une jack-o-lantern. Pour cela, j'ai donc commencé par trouver mes sources, afin d'avoir des modèles à suivre :

Je connais maintenant les proportion a respecter, cependant cette texture est composée de 16 pixels de haut et de large. Ainsi pour me faciliter la tache, je modéliserais une citrouille de 16 cm avec des pixels de 1cm que je réduirais ensuite a 10 cm, en gardant les proportions.
J'ai donc commencé par créer ma base, un carré de 10cm de couleur rouge.
Ensuite, j'ai dessiné un segment de droite de longueur 1 cm puis en plaçant le carré initial aux coordonnées (0;0), je pouvais placer assez simplement ce segment pour suivre le contour des parties sombres. Je n'avais plus qu'a respecter la positon de chacun de ces segments sur mon dessin en rentrant sa coordonnée précise à la main. J'ai d'abord fait tout les segments horizontaux :

Enfin, j'ai pivoté le même segment d'exactement 90° et refait la manipulation pour tout les segments horizontaux. Pour finir, j'ai rempli les 3 parties avec l'outil "sceau", de la couleur noire puis le dessin final était prêt. Une fois passé a la graveuse laser, voici le résultat.

Voici le projet 2D final : Citrouille inkscape.svg
Modélisation 3D (Blender) :
Pour commencer, j'ai décidé de faire cette modélisation sur blender, car, même si plus complexe a prendre en main, il me semble plus complet et je vois ca comme l'occasion d'apprendre a maitriser un logiciel plus polyvalent.
J'ai décidé pour cette modélisation, de créer un "pot de fleur" capable de maintenir une rose en lego avec un certain angle. Comme pour la modélisation 2d la première étape a était de trouver un modèle a suivre, or cette fois ci j'ai du le créer moi-même, en prenant soin de mesurer la rose en lego et plus précisément sa tige.

J'ai ensuite construit la forme de base, un cercle, que j'ai étiré puis dans lequel j'ai crée des faces, pour obtenir une surface. Après avoir extrudé et modifié celle ci pour avoir le volume souhaité, je me retrouve avec ceci :

Apres cela, j'ai crée un cylindre penché, auquel j'ai supprimé les deux faces opposés. Ensuite, j'ai extrudé les différents points des deux cercles restant et j'ai enfin réduit la taille des cercles extrudés. Ainsi, en créant des faces entres les nouveaux cercles du haut et du bas, j'avais la forme générale qui allait tenir la tige:

Enfin, après avoir assemblé les deux pièces, je n'ai plus eu qu'a gérer les proportions et la taille générale de l'objet pour quelle corresponde à mes mesures initiales:

Voici donc l'objet final :Pot de fleur.stl

Malick
PROJET 2D (Inkscape) :
Pour mon projet 2D, j'ai décidé de faire une plaque en bois avec un numéro de porte dessus. Les numéros de porte étant écrits avec un style particulier mes compétences artistiques seront mises à rude épreuve. Pour rendre l'exercice plus intéressant il me fallait trouver un style de 4 particulier. J'ai eu 2 idées principales:
- un circuit de course style Mario Kart en forme de 4
- un 4 avec la calligraphie de Zelda BOTW
Je suis finalement parti pour le 4 avec une calligraphie hylienne. Je me suis basé sur ce modèle:

Et voilà mon projet 2D : Numéro porte 4 

PROJET 3D (Freecad) :
Pour mon projet 3D, je suis parti pour modéliser un flocon de neige. La structure du flocon étant assez complexe, modéliser le flocon me permettra diverses fonctionnalités de l'outil Freecad.

Tout d'abord il me fallait un croquis que j'allais suivre dans la réalisation de mon flocon. Le voilà :

 

Pour réaliser la structure sur Freecad j'ai vu que la construction se ferait en deux parties :
- Modélisation de l'étoile centrale à 12 branches
- Modélisation du pourtour avec les 6 branches de givre

L'objectif de la première partie était pour moi de faire une belle étoile. Je l'écris car je m'y suis pris à plusieurs fois avant de réussir à en faire une satisfaisante. Le secret de ma réussite : l'outil '' SYMETRIE '' de Freecad:

Cet outil m'a vraiment sauvé la mise car je n'avais plus qu'à faire une partie de l'étoile puis faire une symétrie axiale pour chacune de mes branches.

Une fois l'étoile faite le vrai défi venait de commencer avec les 6 branches externes.
J'ai donc dû me diviser cette grande en une multitude de petite tâche que voici :
- Faire le ''premier rempart'' qui est l'hexagone avec des espaces

- Ajouter les ''premières routes''
- Faire les premiers arcs de cercles sur les fins de routes grâce à l'outil '' créer un arc ''

- Ensuite on refait la même chose comme une sorte de fractale avec un ''deuxième niveau de route'' et les deuxièmes arc de cercles
Finalement on obtient la givre voulu : Givre 

Sophie
Modélisation 2D :
Pour ma modélisation 2D, j'ai utilisé le logiciel Inkscape pour dessiner une guitare. J'ai utilisé l'outil qui permet de tracer des courbes de Bézier et des Segments de droites pour dessiner son contour et ses détails. La forme particulière de la guitare m'a permis de réellement prendre en main cet outil. J'ai ensuite mis en rouge les contours "à découper" et en noir les contours à tracer.

La guitare : guitar..svg
Sur le logiciel Inkscape :

Une fois gravé, voici le résultat :

 
Un bug sur la découpeuse laser directement a empêché la réalisation d'un des petits trous sur la partie fine de la guitare. Je suis tout de même satisfaite du résultat.

Modélisation 3D :
Pour ma modélisation 3D, j'ai utilisé le logiciel FreeCAD pour créer un poisson. J'ai utilisé la section Sketcher dans un premier temps pour dessiner la forme de mon poisson et de ses nageoirs etout en leur ajoutant des contraintes de symétries, puis je suis passée par Part Design pour leur donner des dimensions (en utilisant l'outil protrusion pour le corps et par l'outil Extrusion pour les nageoirs) ainsi que pour "creuser" les yeux. J'ai pris soin de ne former qu'un seul corps qui comprenait les nageoirs et le corps du poisson, pour que l'imprimante 3D ne les imprime pas en plusieurs parties différentes, ce qui amènerait à un échec d'impression.

Voici mon poisson : poisson.FCStd
Sur le logiciel Freecad :

Vous pouvez voir ici le résultat de l'impression 3D :

Paul
Modélisation 2D :
Pour ma modélisation 2D, je me suis inspiré de la technique de "wood layering" qui constiste en la superposition de couches de bois, découpées, afin de donner une sensation de profondeur à des objets plutôt en 2 dimensions.
J'ai designé un visage à partir de plusieurs pièces qui je vais pouvoir attacher et faire bouger à ma convenance :

(fichier frenchounet.svg)

Enfin, j'ai utilisé des attaches parisiennes afin d'accrocher mes différentes parties.
Modélisation 3D :
J'ai utilisé FreeCAD pour réaliser cette modélisation. Je voulais continuer à m'entrainer en manipulant les formes de base proposées par le logiciel. Pour mes prochaines modélisations, je souhaites passer par la section Part Design qui me semble beaucoup plus pratique, efficace et ouvre bien plus le champ des possibles.
Pour l'instant du moins, j'ai décidé de réaliser une maison en forme de champignon :

Fichier : Maison Champignon

La seule surprise que j'ai eu, qui résulte d'une erreur, était que le chapeau et le tronc étaient en fait séparés. Je n'avais pas fusionné les deux parties sur FreeCAD, n'ayant pas encore tout à fait bien saisi toutes les subtilités du logiciel. C'est une erreur que je n'ai pas reproduit sur mes modélisations suivantes. Etant donné qu'il y a avait un trou sous le chapeau dans lequel la base ne passait pas, j'ai du le boucher avec des pièces de carton et coller le tout.

De plus cette séance a été pour nous l'occasion de dépasser la partie "software" de cette UE et de voir concrètement ce qu'il été possible de fabriquer. En effet, nous avons assisté à la présentation des machines disponibles au FabLab ainsi qu'à leur fonctionnement. Nous savons maintenant comment les manipuler en toute sécurité, quelles sont leurs limites, les différents matériaux qu'il est possible d'utiliser ainsi que plusieurs autres subtilités. Ceci nous ouvre à l'immense champ des possibles de cette UE.

Ainsi, il était venu l'heure des tests. A quelle point cette machine pour graver le bois au laser est elle précise ? Combien de temps met-elle pour graver une pièce d'une dizaine de centimètre ? Testons. Et quoi de mieux qu'un dessin de Pac-Man pour ce test ?

Ainsi, nous avons eu réponse à nos interrogations, en environ 3 minutes, la machine avait fini de graver et découper cette pièce, nous bluffant par sa précision, son niveau de détail et sa simplicité d'utilisation.
Séance 4 : 21/02/2023 -----------------------------------------------------
Le but de cette séance était de réellement commencer à travailler sur notre projet pour cette UE. Nous avons dans un premier temps décidé de laisser de côté la partie Design de notre projet, car nous hésitions entre plusieurs choix (robot avec une coque en forme de cafard, de pacman ou de mouche), nous nous occuperions donc de l’impression 3D de la coque de notre robot une fois le robot lui même fini.

Test de capteurs
Aujourd’hui nous avons donc choisi les capteurs qui nous paraissaient les plus adaptés pour notre idée de faire un robot qui fuit lorsqu’on s’approche de lui. Nous sommes donc partis sur des capteurs de mouvement. Nous hésitions avec un capteur de distance mais l’idée est bien que notre robot capte un humain ou objet qui le poursuit, donc en mouvement, et non pas n’importe quel objet qui se trouve autour de lui (comme un mur par exemple).

Nous avons donc pu tester différents modèles de capteurs en les codant simplement sur Arduino :

Le premier que nous avons testé fonctionnait parfaitement bien (deux photos de droite). Cependant, nous n'avons pas réussi à trouver (même en fouillant tous les projets imagineables ayant utilisé ce modèle exact de capteur sur internet) comment régler la distance à laquelle le mouvement peut être détecté. En effet, il nous faudrait une distance de 0 à 3 mètres environ et ce capteur allait jusqu'à 6 mètres.

Nous avons donc essayé un autre modèle (photos de gauche, mini PR Motion Sensor) mais les tests ont été un peu plus compliqués dans la mesure où ce capteur était beaucoup trop sensible, en plus du fait que, même si cette fois-ci nous savons régler la distance (il détectait les mouvement jusqu'à 6m autour de lui, ce qui est trop pour nous), cela reviendrait à modifier la carte mère. Il nous paraissait donc plus simple de commander un modèle de capteur avec une distance et un angle pré établis qui nous conviennent.

Cette séance nous a permis de nous familiariser avec la programmation de ce genre de capteurs, nous n'avons donc pas produit de programme pour notre projet mais nous avons pu manipuler le programme suivant (fourni sur le Wiki PIR Motion Sensor) :
#define PIR_MOTION_SENSOR 2//Use pin 2 to receive the signal from the module
 
 
void setup()
{
 pinMode(PIR_MOTION_SENSOR, INPUT);
 Serial.begin(9600); 
 
}
 
void loop()
{
 if(digitalRead(PIR_MOTION_SENSOR))//if it detects the moving people?
 Serial.println("Hi,people is coming");
 else
 Serial.println("Watching");
 
 delay(200);
}
Matériel nécessaire :

4x Grove PIR Motion Sensor : https://www.seeedstudio.com/Grove-PIR-Motion-Sensor.html
Séance 5 : 24/02/2023 -----------------------------------------------------
Cette séance, nous nous sommes fixés plusieurs objectifs :

Faire la liste des éléments qui composent notre projet
Prendre en main un relai et l'incorporer dans le circuit d'alimentation d'un moteur
Prendre en main la commande de signal (programmer la sortie d'un signal de manière interne au M5) sur un M5Stack pour ensuite faire fonctionner un moteur et finalement le relai.

En ce qui concerne la "dissection" de notre projet, voici ce que nous en avons tiré :

Châssis (à concevoir nous-mêmes)
Moteurs
Alimentation (par piles)
Batterie externe pour alimenter la carte Arduino
4x  Capteurs Grove PIR Motion Sensor
Arduino UNO
Motor Shield
Interrupteur manuel pour allumer éteindre complètement
LED indicatrice ON/OFF
"Coque" / "Carapace pour fermer le tout et protéger l'électronique (à concevoir nous-mêmes)
Vis, écrous, tiges, engrenages...? (à concevoir nous-mêmes ?)
Cables Groves, Duponts...

Prise en main du relai :
Nous voulions utiliser un relai pour commander l'activation des moteurs. Nous avons donc fait des esais avec un relai Grove , qui ont été plutôt concluant. Cependant, nous n'avons pas gardé cette idée une fois que nous avions utilisé le Motor Shield ARDUINO, qui possède une fonctionnalité similaire en interne.

Commande de signal :
Le but ici était de réussir à programmer la sortie d'un courant depuis le M5, qui servira ensuite à alimenter des relais, eux-même connectés aux moteurs. Nous avons utilisé le Module PLUS du M5 pour avoir une connexion GPIO. Pour l'instant sans succès avec un moteur, nous avons tout de même pu découvrir le vocabulaire nécessaire sur Arduino. Nous testerons à la prochaine séance avec une LED, voir s'il y a des différences.
#include <Arduino.h>
#include <M5Stack.h>

#define GPIO_PIN26 26
#define GPIO_PIN36 36

void setup() {
 // put your setup code here, to run once:
 M5.begin();
 M5.Power.begin();
 pinMode(26, OUTPUT);

}

void loop() {
 // put your main code here, to run repeatedly:
 digitalWrite(26, HIGH);
 delay(5000);
 digitalWrite(26, LOW);
 delay(5000);
}

Séance 6 : 07/03/2023 -----------------------------------------------------
Lors de cette séance, nous avons continué l'avancée du projet de notre robot en travaillant sur :

Faire fonctionner le moteur avec le module du Motor Shield compatible avec la carte Arduino UNO
Tester le module de détecteur de mouvement PIR Motion Sensor
Le montage du robot

Shield Motor :
Nous avons décidé de ne plus utiliser le M5Stack et de nous concentrer sur la carte ARDUINO munie de plusieurs shields.
Pour monter de la bonne manière le moteur au Motor Shield nous avons trouvé une vidéo Youtube qui est très complète :

On y aborde la composition du shield, son fonctionnement, ses utilisations et surtout son application pour un robot, très bien expliqué et qui nous sera très utile dans la suite de notre projet.
Nous avons donc essayé de contrôler un moteur à l'aide de la carte Arduino ainsi que du Shield Motor. Nous avons d'abord utilisé un programme example pour se familiariser avec la synthaxe propre au shield :
// Adafruit Motor shield library
// copyright Adafruit Industries LLC, 2009
// this code is public domain, enjoy!
#include <Arduino.h>
#include <AFMotor.h>

AF_DCMotor motor(1);

void setup() {
 Serial.begin(9600); // set up Serial library at 9600 bps
 Serial.println("Motor test!");

 // turn on motor
 motor.setSpeed(200);
 
 motor.run(RELEASE);
}

void loop() {
 uint8_t i;
 
 Serial.print("tick");
 
 motor.run(FORWARD);
 for (i=0; i<255; i++) {
 motor.setSpeed(i); 
 delay(10);
 }
 
 for (i=255; i!=0; i--) {
 motor.setSpeed(i); 
 delay(10);
 }
 
 Serial.print("tock");

 motor.run(BACKWARD);
 for (i=0; i<255; i++) {
 motor.setSpeed(i); 
 delay(10);
 }
 
 for (i=255; i!=0; i--) {
 motor.setSpeed(i); 
 delay(10);
 }
 

 Serial.print("tech");
 motor.run(RELEASE);
 delay(1000);
}

Puis nous nous sommes attaqués au coeur du projet : commander les moteurs grâce au détecteur de mouvement. Nous avons écrit un programme qui n'a pas fonctionné, mais qui s'approche fortement de ce que nous cherchons à réaliser :
#define PIR_MOTION_SENSOR 4
#include <Arduino.h>
#include <AFMotor.h>

AF_DCMotor motor(1);

void setup() {
 
pinMode(PIR_MOTION_SENSOR, INPUT);
 Serial.begin(9600);

motor.setSpeed(200); 
motor.run(RELEASE);
}

void loop() 
{
 
 uint8_t i;
 if(digitalRead(PIR_MOTION_SENSOR)) {//if it detects the moving people?
 Serial.println("hey dude");
 motor.run(FORWARD);
 delay(10);
 
 
 delay(10);
 }
 else {
 Serial.println("oh");
 delay(10);
 }
 

}

Et les montages qui nous avons fait :

PIR Motion Sensor :
Du côté du PIR Motion Sensor nous avons testé l'efficacité du détecteur de mouvement et nous avons codé sur Arduino le module. L'objectif était de lui faire afficher sur le moniteur du logiciel Arduino "Hi, People is coming" lorsqu'il détecte du mouvement et "Watching" sinon.

Pour ce faire nous avons trouvé la page wiki du PIR Motion Sensor sur Seeedstudio :

Et voici le code permettant de faire marcher le module :
/*macro definitions of PIR motion sensor pin and LED pin*/
#define PIR_MOTION_SENSOR 2//Use pin 2 to receive the signal from the module
void setup()
{
 pinMode(PIR_MOTION_SENSOR, INPUT);
 Serial.begin(9600); 
}
void loop()
{
 if(digitalRead(PIR_MOTION_SENSOR))//if it detects the moving people?
 Serial.println("Hi,people is coming");
 else
 Serial.println("Watching");
 delay(200);
}

Le module de détection de mouvement a une portée de détection de 3 mètres (comme prévu par le constructeur) et lorsqu'il y avait du mouvement, il affichait les informations sur le serial monitor du logiciel Arduino :

Ensuite nous nous sommes occupés du montage du robot que nous allions utiliser.
Châssis du robot :
Ce robot utilise le Magician Chassis--DG007 que l'on peut trouver sur le site de Gotronic :

Et pour en arriver au résultat ci-dessus nous avons suivi le montage dont on peut trouver le déroulement ici: http://www.pyroelectro.com/tutorials/building_robot_chassis/hardware
Séance 7 : 14/03/2023 -----------------------------------------------------
Programmation

Dans la continuité de la séance dernière, le groupe de codage a continué à travailler sur le code pour que le moteur fonctionne AVEC le module PIR Motion Sensor. Le plus gros problème était que le code faisait fonctionner le moteur seul mais dès qu'on y incluait le module PIR le moteur s'arrêtait de fonctionner. Lorsqu'on incluait le PIR, la connection du PIR prenait le dessus et bloquait la communication entre la carte Arduino et le Motor Shield. Nous avons changé le port du PIR sur le GROVE de D4 à D3.
Nous avons programmé :

Un premier code pour qu'un seul moteur fonctionne selon le comportement du PIR Motion Sensor :

#define PIR_MOTION_SENSOR 3
#include <Arduino.h>
#include <AFMotor.h>
int switchstate = 0;

AF_DCMotor motorA(1);
AF_DCMotor motorB(4);

void setup() {
 motorA.run(RELEASE);
 Serial.begin(9600);
pinMode(PIR_MOTION_SENSOR, INPUT);
}

void loop() 
{
 switchstate = digitalRead(PIR_MOTION_SENSOR);
if(switchstate == HIGH) {
 Serial.println("forward");
 motorA.run(FORWARD);
 motorA.setSpeed(200);
 motorB.run(FORWARD);
 motorB.setSpeed(200);
 delay(1); 
 }
else {
 motorA.run(RELEASE);
 motorB.run(RELEASE);
 Serial.println("release");
 delay(1);
 }
delay(1);
} 
 

Un deuxième code pour tester la connexion entre 2 moteurs et 2 capteurs, en faisant 2 couples moteur/capteur :

#define PIR_MOTION_SENSOR_FRONT 3
#define PIR_MOTION_SENSOR_BACK 6

#include <Arduino.h>
#include <AFMotor.h>
int switchstate_front = 0;
int switchstate_back = 0;

AF_DCMotor motorA(1);
AF_DCMotor motorB(4);

void setup() {
 motorA.run(RELEASE);
 motorB.run(RELEASE);
 Serial.begin(9600);
pinMode(PIR_MOTION_SENSOR_FRONT, INPUT);
pinMode(PIR_MOTION_SENSOR_BACK, INPUT);

}

void loop() 
{
 switchstate_front = digitalRead(PIR_MOTION_SENSOR_FRONT);
if(switchstate_front == HIGH) {
 Serial.println("front");
 motorA.run(FORWARD);
 motorA.setSpeed(200);
 delay(100); 
 }
else {
 motorA.run(RELEASE);
 Serial.println("frontrelease");
 delay(100);
 }

 
 switchstate_back = digitalRead(PIR_MOTION_SENSOR_BACK);
if (switchstate_back == HIGH) {
 Serial.println("back");
 motorB.run(BACKWARD);
 motorB.setSpeed(200);
 delay(100); 
 }
else {
 motorB.run(RELEASE);
 Serial.println("backrelease");
 delay(100);
 }
delay(100);
 } 

Un dernier code qui s'approche très fortement du code final, capable de réaliser les actions de déplacement (rotation, ligne droite, marche arrière...) en fonction du capteur actif :

#define PIR_MOTION_SENSOR_FRONT 3
#define PIR_MOTION_SENSOR_RIGHT 5
#define PIR_MOTION_SENSOR_LEFT 9
#define PIR_MOTION_SENSOR_BACK 6

#include <Arduino.h>
#include <AFMotor.h>
int switchstate_front = 0;
int switchstate_right = 0;
int switchstate_left = 0;
int switchstate_back = 0;

AF_DCMotor motorR(1);
AF_DCMotor motorL(4);

void setup() {
 motorR.run(RELEASE);
 motorL.run(RELEASE);
 Serial.begin(9600);
pinMode(PIR_MOTION_SENSOR_FRONT, INPUT);
pinMode(PIR_MOTION_SENSOR_RIGHT, INPUT);
pinMode(PIR_MOTION_SENSOR_LEFT, INPUT);
pinMode(PIR_MOTION_SENSOR_BACK, INPUT);

}

void loop() 
{
//Capteur FRONT

switchstate_front = digitalRead(PIR_MOTION_SENSOR_FRONT);
if(switchstate_front == HIGH) {
 Serial.println("front");
 motorR.run(BACKWARD);
 motorR.setSpeed(250);
 motorL.run(BACKWARD);
 motorL.setSpeed(250);
 delay(3000); 
 }
else {
 motorR.run(RELEASE);
 motorL.run(RELEASE);
 Serial.println("frontrelease");
 delay(100);
 }

 
//Capteur RIGHT

switchstate_right = digitalRead(PIR_MOTION_SENSOR_RIGHT);
if(switchstate_right == HIGH) {
 Serial.println("right");
 motorR.run(FORWARD);
 motorR.setSpeed(250);
 motorL.run(RELEASE);
 delay(1000); 
 }
else {
 motorR.run(RELEASE);
 motorL.run(RELEASE);
 Serial.println("rightrelease");
 delay(100);
 }

//Capteur LEFT

switchstate_left = digitalRead(PIR_MOTION_SENSOR_LEFT);
if(switchstate_right == HIGH) {
 Serial.println("left");
 motorL.run(FORWARD);
 motorL.setSpeed(250);
 motorR.run(RELEASE);
 delay(1000); 
 }
else {
 motorR.run(RELEASE);
 motorL.run(RELEASE);
 Serial.println("leftrelease");
 delay(100);
 }
//Capteur BACK
 
 switchstate_back = digitalRead(PIR_MOTION_SENSOR_BACK);
if (switchstate_back == HIGH) {
 Serial.println("back");
 motorR.run(BACKWARD);
 motorR.setSpeed(250);
 motorL.run(BACKWARD);
 motorL.setSpeed(250);
 delay(100); 
 }
else {
 motorR.run(RELEASE);
 motorL.run(RELEASE);
 Serial.println("backrelease");
 delay(100);
 }
delay(100);
 } 
Conception et réadaptation d'un châssis
Dans un deuxième temps nous nous sommes occupés du montage de notre robot et une difficulté est apparue : la taille des composants dont nous disposions n'étaient pas calibrée avec le châssis. En effet, les modules que nous voulions fixer au châssis étaient trop grand ou trop petit par rapport au châssis.

Pour pallier à ce problème, 2 choix s'offraient à nous :

Recréer le châssis de zéro en y incluant des accroches pour les composants que nous allons y placer (moteurs, capteurs, batteries…)
Garder le châssis de base et créer des accroches pour les composants que nous allons y placer (moteurs, capteurs, batteries…)

Nous sommes partis sur la 2e option et allons modéliser sur Freecad, 4 accroches pour les modules PIR que nous allons fixer.
Pour accrocher les capteurs, nous avons opté pour une accroche en forme de L plié. Les piles et la carte Arduino possèdent des trous pour les visser directement. On fixera donc les piles en dessous du robot et l'Arduino au dessus. Les moteurs quant à eux, seront au milieu avec les accroches pré-fournies. Enfin, pour l'interrupteur et la LED (que nous n'avons finalement pas implémenté), nous les placerons à côté des piles en fabriquant une accroche. Ainsi tous les composants seront placés et il ne resterait plus qu'à modéliser une "coque" (le corps du robot).  

Modèle 3D des supports pour PIR Motion Sensor (fichier Support capteurs.FCStd & Support capteurs - Inverse.FCStd) :

Séance 8 : 21/03/2023 -----------------------------------------------------
Impression des supports pour capteurs
Durant cette séance, nous avons fait des finitions sur le modèle 3D des supports pour les PIR Motion Sensor, puis nous en avons lancé deux en impression 3D pour être sûrs de voir le résultat avant la fin de la séance. Les résultats finaux était très satisfaisant mais il nous a tout de même permis de repérer deux problèmes :

Un problème de modélisation : erreur humaine. Le long trou du socle n'avait pas été perforé entièrement sur le fichier .stl, nous nous sommes donc retrouvés avec un socle bouché et trop épais pour pouvoir tenter de réparer le problème.
Les trous prévus pour fixer les capteurs étaient trop proches d'environ 1 mm.

Nous avons en même temps démarré les impressions 3D et découpes laser pour terminer nos projets personnels (séance 3).

Soudures
Avant d'assembler le robot, nous devions nous charger de souder tous les fils : soit ensemble, soit avec des moteurs... Nous nous sommes initiés à la soudure, à la façon d'étaler de l'étain sur des fils, de placer des gaines thermorétractables. A la fin de la séance, il ne nous manquait plus que 4 soudures afin de rallonger certains fils.

Début de l'assemblage du robot
Nous avons surtout remonter ensemble les moteurs, le bloc de piles et la carte ARDUINO sur le chassis du robot.
Séance 9 : 28/03/2023 -----------------------------------------------------
Résultat final des supports de PIR Motion Sensor
Nous avons récupéré les supports pour les capteurs qui nous avions imprimé en 3D. Le résultat était très satisfaisant :

Ils sont solides
Ils sont peu encombrants
L'espacement des trous pour les vis est exact pour bien faire tenir le capteur
Le diamètre des trous de vis est parfait : suffisamment étroit pour ne pas avoir besoin d'écrou à l'arrière sans pour autant devoir forcer énormément lorsque qu'on visse.

(nous n'avons finalement pas utilisé le modèle ci-dessus mais la version où la fixation est positionnée sur le dessus, que l'on peut voir dans les images suivantes)
Fin de l'assemblage du robot
Avant de pouvoir nous pencher sur la programmation, il fallait finir d'assembler le robot. Nous avons commencé par quelques soudures afin de rallonger les fils reliés aux moteurs pour qu'ils atteignent les entrées du Motor Shield. Ensuite nous avons fait passer les fils à travers les trous du châssis, de manière à avoir un câblage clair et pratique. Nous les avons connecté aux bonnes entrées. On a aussi attaché les capteurs à l'avant et à l'arrière du robot.

L'assemblage final a été réalisé quelques jours plus tard, afin de s'occuper des détails : l'emplacement de la batterie pour la carte Arduino, fixer (solidement) l'interrupteur. Ceci a été fait avec des colliers de serrage car ils sont pratiques, faciles à poser et simple à retirer si on veut changer quoi que ce soit. Le robot, finalement, ressemble à ceci :

Echecs du code

Une fois que l’assemblage du robot était fini, il était temps de tester notre code final de la dernière séance, mais avec seulement deux capteurs (par défaut de commande, les deux derniers ne sont jamais arrivés). Placés à l’arrière du robot, avec un sur chaque côté, notre robot devrait capter tout ce qui arrive des deux côtés et derrière lui.

Nous avons donc remodifer le code : une détection à l’arrière gauche du robot le fait tourner à droite puis avancer et une détection à l’arrière droit le fait tourner à gauche puis avancer, en prenant soin d’arrêter les moteurs au bout d’un certain temps pour que le robot ne capte pas les murs ou le plafond qui sont en mouvement par rapport à lui lorsqu’il bouge.

Lorsqu’on a lancé le code, le robot se mettait certes à tourner et à avancer lorsqu’on l’allumait, mais soit de manière très aléatoire, soit il arrêtait complètement de capter au bout d’un certain moment (malgré le fait qu’on avait mis des délais assez courts). En plus de tout ça, il avait l’air de ne capter que du côté gauche, car il ne tournait qu’à droite à chaque fois qu’on l’allumait. 
Théories sur les différents problèmes qu’on a rencontré :

comme à la séance 7, des branchements se gêneraient entre eux
un des capteurs était peut être défaillant
les délais ne convenaient peut être pas au temps de réaction des capteurs
les capteurs se marchaient l’un sur l’autre (quand l'un détecte un mouvement, l’autre aussi et les codes se confondent)
une partie du code (le premier if du capteur gauche) aurait la priorité sur une autre (le if du deuxième capteur)

Après avoir essayé de modifier les délais, de changer les branchements, de tester les capteurs un par un, notre code ne fonctionnait toujours pas comme on le souhaitait. Les capteurs se gênaient donc entre eux et la première partie du code était prioritaire sur la deuxième, ce qui gênait la détection du capteur droit. 
Il fallait donc que l’on trouve :

soit une manière de mettre les deux conditions du code sur le même pied d’égalité

soit une commande qui nous permettrait d’éteindre un capteur lorsque l’autre détecte du mouvement, afin qu’ils ne se gênent plus entre eux.

Voici notre code défectueux :
#define PIR_MOTION_SENSOR_RIGHT 6
#define PIR_MOTION_SENSOR_LEFT 3

#include <Arduino.h>
#include <AFMotor.h>
int switchstate_right = 0;
int switchstate_left = 0;

AF_DCMotor motorR(1);
AF_DCMotor motorL(4);

void setup() {
 motorR.run(RELEASE);
 motorL.run(RELEASE);
 Serial.begin(9600);
pinMode(PIR_MOTION_SENSOR_RIGHT, INPUT);
pinMode(PIR_MOTION_SENSOR_LEFT, INPUT);

}

void loop() 
{

//Capteur RIGHT

switchstate_right = digitalRead(PIR_MOTION_SENSOR_RIGHT);
if(switchstate_right == HIGH) {
 Serial.println("right");
 motorR.run(FORWARD);
 motorR.setSpeed(250);
 motorL.run(BACKWARD);
 delay(500); 
 motorR.run(FORWARD);
 motorL.run(FORWARD);
 delay(1000);
 }
//Capteur LEFT

switchstate_left = digitalRead(PIR_MOTION_SENSOR_LEFT);
else if(switchstate_right == HIGH) {
 Serial.println("right");
 motorL.run(FORWARD);
 motorR.setSpeed(250);
 motorR.run(BACKWARD);
 delay(500); 
 motorR.run(FORWARD);
 motorL.run(FORWARD);
 delay(1000); 
 }

else {
 motorR.run(RELEASE);
 motorL.run(RELEASE);
 Serial.println("release");
 delay(1000);
 }
}
Finition du code et test
C'est quelques jours plus tard que nous avons trouvé la solution. En se documentant, on se rend compte qu'il n'existe pas de synthaxe pour "éteindre" un capteur. En revanche une autre idée nous vient. Afin d'utiliser le signal transmis par le capteur, on doit déclarer au début de notre programme sur quelle entrée la capteur est connecté, et surtout le fait qu'il s'agisse d'une entrée.

pinMode(PIR_MOTION_SENSOR_RIGHT, INPUT);
Arduino s'attend alors à recevoir un signal. Or rien ne nous empêche de forcer le Pin du capteur à être une sortie. De cette façon, Arduino ne regarde que les signaux sortants (qui n'existent pas puisque ça n'aurait pas de sens) et ne fait plus attention aux signaux entrants : c'est une sorte de sens unique. On implémente alors deux lignes qui permettent en début de condition de mettre l'autre capteur en OUTPUT, suivit de toutes les commandes puis à la toute fin, une ligne pour faire passer de nouveau l'autre capteur en INPUT. Nous n'avions plus de problèmes de superposition de commandes.
Nous avons également ajouté du temps d'arrêt directement à la fin des commandes de mouvement et pas seulement avec une commande à part. Ceci évite au robot d'avoir un air hystérique en enchaînant immédiatement avec un autre mouvement.
if(switchstate_back == LOW) {
 if(switchstate_front == LOW) {
 motorR.run(RELEASE);
 motorL.run(RELEASE);
 Serial.println("release");
 delay(2000);
 }
 }
Enfin, nous avions utilisé une commande else pour immobiliser le robot. Afin d'être certains que cette condition se réalise, nous avons préféré opter pour une imbrication de conditions : de cette façon on est sûr que le robot ne bouge pas quand les deux capteurs ne détectent rien. C'est ainsi que arrivons au programme final :

#define PIR_MOTION_SENSOR_FRONT 6
#define PIR_MOTION_SENSOR_BACK 3

#include <Arduino.h>
#include <AFMotor.h>
int switchstate_front = 0;
int switchstate_back = 0;

AF_DCMotor motorR(1);
AF_DCMotor motorL(4);

void setup() {
 motorR.run(RELEASE);
 motorL.run(RELEASE);
 Serial.begin(9600);
pinMode(PIR_MOTION_SENSOR_FRONT, INPUT);
pinMode(PIR_MOTION_SENSOR_BACK, INPUT);
}

void loop() 
{

switchstate_front = digitalRead(PIR_MOTION_SENSOR_FRONT);
switchstate_back = digitalRead(PIR_MOTION_SENSOR_BACK);

if(switchstate_front == HIGH) { //Capteur FRONT
 pinMode(PIR_MOTION_SENSOR_BACK, OUTPUT);
 Serial.println("front");
 motorR.run(FORWARD);
 motorR.setSpeed(250);
 motorL.run(BACKWARD);
 motorL.setSpeed(250); 
 delay(200);
 motorR.run(BACKWARD);
 motorR.setSpeed(250);
 motorL.run(BACKWARD);
 motorL.setSpeed(250);
 delay(3000); 
 motorR.run(RELEASE);
 motorL.run(RELEASE);
 delay(3500);
 pinMode(PIR_MOTION_SENSOR_BACK, INPUT);
 
 }

if(switchstate_back == HIGH) { //Capteur BACK
 pinMode(PIR_MOTION_SENSOR_FRONT, OUTPUT);
 Serial.println("back");
 motorR.run(BACKWARD);
 	motorR.setSpeed(250);
 motorL.run(FORWARD);
 	motorL.setSpeed(250); 
 delay(200);
 motorR.run(FORWARD);
 	motorR.setSpeed(250);
 motorL.run(FORWARD);
 	motorL.setSpeed(250);
 	delay(3000);
 motorR.run(RELEASE);
 motorL.run(RELEASE);
 	delay(3500);
 pinMode(PIR_MOTION_SENSOR_FRONT, INPUT);
 }
if(switchstate_back == LOW) {
 if(switchstate_front == LOW) {
 motorR.run(RELEASE);
 motorL.run(RELEASE);
 Serial.println("release");
 delay(2000);
 }
 }
}
Célébration (avec un peu de chance)
Notre projet est alors terminé, ci-après quelques tests (plus ou moins convaincants) qui démontre du bon fonctionnement du programme et de l'électronique. Un léger "soucis" concerne l'inclinaison des capteurs sur leur support. Le robot étant au niveau du sol fait que le capteur de devant (respectivement de l'arrière) arrive à capter du côté opposé au sien. A part cela, nous sommes très satisfaits.

Séance 10 : 28/03/2023 ----------------------------------------------------
Découpe de Joey :

En début de séance, nous avons rapidement découpé au laser un modèle de Joey (Oggy et les Cafards) afin de sublimer notre création.
On a utilisé une image trouvée sur internet, puis nous avons repassé les contours en rouge (découpe) grâce à l'outil Plume sur InkScape.

Fichier InkScape : joey.svg
Soutenances :

Support Powerpoint disponible en ligne (Google Slides) : Projet Joey
BILAN SUR CE QUI A ÉTÉ RÉALISÉ / NON RÉALISÉ ---------------------
Au fur et à mesure que nous avancions dans notre projet, plusieurs idées ont émergé et d'autres ont été abandonnées. Beaucoup d'entre elles ont abouti mais certaines n'ont pas vu le jour, soit par manque de temps, soit par manque de moyens ou d'expérience. Voici donc le bilan de ce que nous avons fait, et ce qui est resté sur le bord :
CE QUI A ÉTÉ RÉALISÉ

Un circuit électronique fonctionnel comprenant :

2 moteurs
1 carte Arduino UNO + 1 Shield de connectiques + 1 Motor Shield

2 PIR Motion Sensor
1 bloc Pile
1 batterie externe
1 interrupteur

Une structure robuste et pratique composée de :

1 châssis préfabriqué
2 supports pour PIR Motion Sensor faits sur mesure en impression 3D

Un programme fonctionnel sur l'IDE Arduino. Il permet de commander les mouvements du robot en fonction de l'état des capteurs.

CE QUI N'A PAS ÉTÉ RÉALISÉ

Le circuit électronique complet comprenant en tout 4 PIR Motion Sensor
La carapace de notre robot (qui devait initialement ressemblé à un cafard) réalisée soit pas impression 3D ou découpe 2D de pièces suivis de l'assemblage.
La conception entière d'un nouveau châssis pour optimiser la place nécéssaire à nos composants, choisir l'emplacement des trous, des attaches... De même, très certainement par design 3D.
L'implémentation d'autres fonctionnalités telles que :

Un haut-parleur qui lancerait une musique quand le robot fuit
L'utilisation d'un tilt switch qui permettrait au robot de s'éteindre dès qu'on le soulèverait
Utiliser quelques LEDs soit pour un côté pratique, sinon par souci d'esthétique.

Grâce à ce projet, nous avons appris à nous familiariser avec les logiciels de modélisation 3D (FreeCAD, OpenSCAD) et 2D (InkScape) en plus des machines à notre disposition (imprimantes 3D, découpeuse laser...). Aussi, nous avons découvert la programmation de composants électroniques grâce au logiciel ARDUINO couplé aux composants SeeedStudio. On s'est également initiés à des tâches plus classiques comme la soudure pour notre circuit électronique. Ce projet était aussi très formateur du point de vue du travail de groupe. On a chacun réussi à s'inclure dans le projet en fonction de notre niveau. De plus, on a su rebondir sur nos échecs en proposant des solutions ou alternatives. En général, nous avons fait preuve de persévérance afin d'arriver à ce résultat époustouflant. Enfin, le travail de documentation était une nouveauté majeure inhérente à ce projet. Cet aspect est d'autant plus pertinent que les compétences acquises grâce à celle-ci nous servirons sans aucun doute dans nos futurs projets.
Groupe A2 doigts du succès

Membres du groupe : Alex CANAVAGGIO, Angèle EDMOND, Louise GALLY, Alicia LUONG

Séance 1 : Découverte du Fablab
Au cours de cette première séance, nous avons découvert le Fablab de Sorbonne Université. Cet endroit possède une capacité de création sans limites notamment grâce aux équipements et matériaux disponibles. Etant encore récent, le fablab est disponible au public et en libre-service afin de permettre un réel partage de savoir. Dans le cadre du projet que nous souhaitons réaliser, nous devons y incorporer un capteur permettant d'effectuer des mesures environnementales.

Séance 2 : Introduction à Arduino
Pendant cette deuxième séance, nous avons découvert les bases du prototypage avec un Arduino Uno puis avec un M5.
Avec l'Arduino, nous avons d'abord commencé par le connecter au logiciel sur le PC, puis nous avons connecté un capteur température/humidité. En recherchant les codes d'instructions sur le wiki de Seeed Studio, nous avons réussi à récupérer les données sur l'Arduino, puis sur un écran que nous avons également connecté. On a ensuite changé quelques paramètres pour rendre l'affichage sur l'écran plus agréable (couleur, texte, alignement...)

#include <Wire.h>
#include "rgb_lcd.h"
#include "SHT31.h"
 
rgb_lcd lcd;
SHT31 sht31 = SHT31();
 
// définir la couleur du fond
const int colorR = 255;
const int colorG = 100;
const int colorB = 0;
 
void setup() 
{
 // définir le nombre de colonnes et de lignes de l'écran LCD:
 lcd.begin(16, 2);
 
 lcd.setRGB(colorR, colorG, colorB);
 lcd.print("Bonjour !"); // message s'affichant les premières secondes

 sht31.begin();
 
 delay(1000);
}
 
void loop() 
{
 // mettre le curseur à la colonne 0 et ligne 0
 lcd.setCursor(0, 0);

 // afficher la température sur l'écran en utilisant la valeur fournie par le capteur
 lcd.print("Temp : ");
 float temp = sht31.getTemperature();
 lcd.print(temp);
 lcd.print(" C");

 // afficher l'humidité sur l'écran en utilisant la valeur fournie par le capteur
 lcd.setCursor(0, 1);
 lcd.print("Hum : ");
 float hum = sht31.getHumidity();
 lcd.print(hum);
 lcd.print(" %");

 delay(1000);
}

Nous sommes ensuite passés au M5. C'est un capteur plus complet et plus récent, mais dont l'utilisation de l'écran est un peu plus complexe. Nous avons donc recherché les instructions sur le wiki, et lancé un programme "Hello World", en utilisant le code disponible sur Github.
https://github.com/m5stack/M5Stack/blob/master/examples/Basics/HelloWorld/HelloWorld.ino

Enfin, nous avons essayé d'afficher les valeurs prises par le capteur de température et humidité sur le M5. Pour cela, on a utilisé la bibliothèque "Freefonts", téléchargée préalablement sur Github.

#include <M5Stack.h>
#include <Wire.h>
#include "SHT31.h"

#include "Free_Fonts.h" // Include the header file attached to this sketch

unsigned long drawTime = 0;
SHT31 sht31 = SHT31();

void setup(void) {
 M5.begin();
 M5.Power.begin();
 sht31.begin(); 
}

void loop() {
 M5.Lcd.setTextColor(TFT_BLUE); // couleur du texte

 M5.Lcd.setFreeFont(FSBI24); // choix de la police
 
 	// position du curseur sur l'écran
 int xpos = 10; 
 int ypos = 60;

 M5.Lcd.fillScreen(TFT_BLACK); // remplir l'écran en noir pour effacer ce qui a été écrit précédemment 
	
 	// affichage de la température 
 M5.Lcd.drawString("Temp :", xpos, ypos, GFXFF); // texte, x, y, police
 float temp = sht31.getTemperature();
 M5.Lcd.drawFloat(temp, 2, xpos+150, ypos); //nombre flottant, nb de chiffres après la virgule, x, y
 M5.Lcd.drawString(" C", xpos+260, ypos, GFXFF);
 ypos += 1.6*M5.Lcd.fontHeight(GFXFF); // retour à la ligne 

 	// affichage de l'humidité
 M5.Lcd.drawString("Hum :", xpos, ypos, GFXFF);
 float hum = sht31.getHumidity();
 M5.Lcd.drawFloat(hum, 2, xpos+140, ypos);
 M5.Lcd.drawString(" %", xpos+250, ypos, GFXFF);
 
 delay(2000);
}

Séance 3 : Découverte des logiciels de dessin graphique
Au cours de cette séance, on a découvert des logiciels de dessins graphiques.

Le premier étant le logiciel Inkscape, avec lequel on peut effectuer des images en 2D servant notamment afin de servir par la suite comme modèle pour gravure ou découpeuse laser. On s'est tout d'abord entrainés à la prise en main de ce logiciel en réalisant des dessins simples.

Par la suite, nous avons utilisé le logiciel OpenSCAD qui permet de réaliser des modélisations 3D, permettant ainsi de concevoir des objets 3D.

Un autre logiciel permettant cette même réalisation est FreeCAD, ci dessous le même objet avec cette application.

Projet

Notre projet pour ce semestre consiste en l'assemblage d'un robot capable d'avancer en ligne droite, auquel nous incorporerons un capteur sonore. Le but est ainsi de relier la vitesse de rotation des roues à l'intensité sonore, afin que plus il y ait de bruit, plus le robot avance rapidement. Nous allons ajouter à ce robot un détecteur de distance, de manière à ce qu'il s'arrête automatiquement devant un obstacle.
Pour la structure de base du robot, nous allons reprendre un modèle déjà préconçu, que nous assemblerons au FabLab, puis le modifierons, notamment esthétiquement.

Structure du robot

Robot : https://www.gotronic.fr/art-chassis-magic-dg007-p-25708.htm

Le capteur

Capteur d'intensité sonore : https://wiki.seeedstudio.com/Grove-Loudness_Sensor/ (on choisit celui-ci car le capteur de son également testé était trop sensible pour notre utilisation)
int loudness;
 
void setup()
{
 Serial.begin(9600);
}
 
void loop()
{
 loudness = analogRead(0);
 Serial.println(loudness);
 delay(200);
}

On a téléversé le programme et ouvert la console série pour visualiser les valeurs de la variable loudness. En testant plusieurs intensités sonores, on en a déduit que l'amplitude de la variable s'étend entre 0 et 300 environ quand on crie proche du capteur.

Faire tourner les moteurs à partir d'un seuil d'intensité sonore
On a d'abord essayé de faire avancer le robot à partir d'un seuil d'intensité sonore, qu'on a fixé à loudness = 100 puisque cette valeur est facilement dépassée lorsqu'on parle. Le problème étant que la carte Arduino ne délivre que des tensions de 0 et 5V, on ne peut pas faire fonctionner les moteurs sans amplifier cette tension. On a donc commencé par essayer d'allumer une LED pour établir le seuil qu'on utilisera.

int loudness;
 
void setup()
{
 Serial.begin(9600);
 pinMode(3, OUTPUT);
}
 
void loop()
{
 loudness = analogRead(0);
 Serial.println(loudness);
 if (loudness > 100) {
 digitalWrite(3, HIGH);
 }
 else { 
 digitalWrite(3, LOW);
 }
 delay(200);
}
Pour pouvoir faire fonctionner les moteurs, nous devions donc utiliser une source d'alimentation délivrant une tension adaptée au moteur. Nous avons utilisé les piles fournies avec le robot.

Pour connecter cette alimentation, nous avons utilisé un relay.

Enfin, nous avons effectué le même branchement en reliant les câbles aux moteurs des roues du robot. Chaque roue possède son moteur : si on branche les 2 moteurs en parallèle, ils tournent à la même vitesse que s'il n'y avait qu'un moteur, et si on les branche en série ils tournent 2 fois moins vite.

Faire tourner les moteurs à une vitesse proportionnelle au niveau sonore

Ainsi, pour le moment notre robot avance lorsque le volume sonore dépasse une certaine intensité. Notre but est maintenant de faire varier la vitesse des moteurs proportionnellement au volume sonore.
Pour cela, on essaye d'utiliser le signal PWM de l'Arduino.
La carte Arduino délivre en sortie un signal numérique, qui ne peut prendre que deux valeurs : 0 et 5V. Or on veut que les moteurs tournent à des vitesses différentes, donc il faut que l'Arduino délivre des tensions entre ces deux bornes. La PWM (Pulse Width Modulation = modulation de largeur d'impulsion en français) permet de créer un signal analogique à partir du signal numérique fourni par l'Arduino. Le signal pourra alors varier parmi 256 valeurs (entre 0 et 255) et non plus seulement entre les deux valeurs précédentes.
La tension délivrée par le signal PWM est la tension moyenne délivrée par l'Arduino pendant une durée courte correspondant à une fréquence de 500 Hz. Ainsi, si le signal délivré par la carte Arduino pendant cette durée est toujours de 5V, le signal PWM sera aussi de 5V, et s'il est toujours de 0V, le signal PWM sera aussi de 0V. Par contre, on va pouvoir faire varier le rapport cyclique du signal en sortie de l'Arduino, c'est-à-dire le pourcentage de la durée où l'on fait la moyenne pendant lequel le signal de l'Arduino a une tension de 5V. Par exemple, si le signal délivré par l'Arduino varie entre 0 et 5V pendant des durées égales, le rapport cyclique sera de 50% et le signal PWM délivré aura une tension de 50%*5V = 2,5V.

Source : https://electrotoile.eu
Pour pouvoir exploiter le signal PWM de l'Arduino, nous avons eu besoin d'un shield pour moteurs.
On a donc commencé par installer la bibliothèque correspondant à ce nouveau composant sur Arduino : https://github.com/adafruit/Adafruit-Motor-Shield-library

Ce nouveau composant nous permet de brancher directement les moteurs sur le shield sans avoir à utiliser de relay et de source de tension externe.
Afin de comprendre comment fonctionne notre nouveau circuit, on a commencé par reproduire l'étape précédente, c'est-à-dire faire tourner les moteur à partir d'un certain seuil d'intensité :
#include <AFMotor.h>
int loudness;

AF_DCMotor motor(1);

void setup() {
 Serial.begin(115200); // set up Serial library at 115 200 bps

 // turn on motor
 motor.setSpeed(200);
}

void loop() {
 loudness = analogRead(0);
 Serial.println(loudness);

 if (loudness>100) { // seuil
 motor.setSpeed(255); // vitesse du robot entre 0 et 255
 motor.run(FORWARD); // si l'intensité sonore dépasse le seuil, le robot avance à la vitesse fixée
 delay(100);
 }
 else {
 motor.run(RELEASE); // sinon le robot s'arrête 
 delay(100);
 }
}
L'amplitude de la valeur loudness s'étendant entre 0 et jusqu'à environ 200 lorsqu'on crie, on a donc décidé pour le moment de tout simplement mettre la vitesse du robot à la valeur donnée par le capteur.
#include <AFMotor.h>
int loudness;

AF_DCMotor motor(1);

void setup() {
 Serial.begin(115200); // set up Serial library at 115 200 bps

 // turn on motor
 motor.setSpeed(200);
}

void loop() {
 loudness = analogRead(0);
 Serial.println(loudness);

 if (loudness<255) {
 if (loudness<50) {
 motor.run(RELEASE);
 delay(1);
 }
 else {
 motor.setSpeed(loudness);
 motor.run(FORWARD);
 delay(1);
 }
 }
}
Cependant, nous nous sommes vite rendu compte que lorsque le moteur se met à tourner, la courbe de l'intensité sonore tracée par le serial plotter de l'application Arduino affichait des valeurs allant jusqu'à 500-600.

Nous avons pensé dans un premier temps que le bruit provoqué par les moteurs influençait la valeur fournie par le capteur. Mais cette hypothèse ne tenait pas puisque les mêmes valeurs subsistait quelle que soit la distance du moteur avec la capteur.

On nous a alors suggéré qu'il s'agissait peut-être d'une perturbation du signal d'entrée du capteur et de sortie pour faire fonctionner les moteurs, pouvant provenir du fait que les shields Grove et moteur sont imbriqués l'un au dessus de l'autre au dessus de l'Arduino. On a donc essayé de séparer les 2 shields en utilisant 2 cartes Arduino. On a séparé les programmes et connecté les Arduino, mais le problème semblait légèrement diminué mais persistait : une fois un son détecté, le moteur se met en marche et ne s'arrête plus, puisque la valeur délivrée par le capteur ne correspond plus du tout à l'intensité sonore environnante.
Par peur de manque de temps créé par ce problème nous nous sommes rendu au Fablab pendant les heures d'ouverture au public. Nous voyant en difficulté, un étudiant travaillant au Fablab et un visiteur du Fablab nous ont gentiment proposé leur aide et suggéré que le problème venait du manque de courant fournit à la carte Arduino. En effet, les ports USB de l'ordinateur délivrent un courant de 500 mA, ce qui ne suffisait pas pour faire fonctionner la carte Arduino avec ses 2 shields.
On a alors débranché la carte du port USB et on l'a alimentée directement en la branchant à la table : immédiatement, notre robot s'est mis à fonctionner parfaitement comme nous l'avions programmé !
#include <AFMotor.h>
int loudness;

AF_DCMotor motor(1); // choix du moteur sur le shield moteur

void setup() {
 Serial.begin(115200); // set up Serial library at 115200 bps

 motor.setSpeed(200); // allume le moteur
}

void loop() {
 loudness = analogRead(0); // lit la valeur de l'intensité sonore sur le capteur
 Serial.println(loudness);

 if ((loudness > 75) && (loudness < 400)) { // borne d'intensité sonore à adapter pour que le robot démarre à partir d'une certaine intensité
 motor.setSpeed(255*loudness/400); // et pour adapter l'intensité maximum à la valeur maximum prise par la fonction set.Speed (entre 0 et 255)
 motor.run(FORWARD);
 delay(100);
 }
 
 else {
 motor.run(RELEASE);
 delay(100);
 }

}
Ensuite, comme nous voulions que le robot puisse tourner, nous avons reproduit le même montage avec le même programme, et nous avons branché les 2 cartes Arduino aux 2 roues de notre robot.  Nous avons alimenté chaque carte avec 4 piles.

Il reste encore à régler la vitesse de rotation des moteurs en adaptant les bornes d'intensité sonore sur le code, pour que le robot avance un peu plus rapidement.

Détecteur de distance
Afin de s'assurer que le robot ne fonce pas dans un mur, nous avons décidé d'y ajouter un capteur de distance, pour qu'il arrête automatiquement d'avancer lorsqu'il est à moins de 30cm d'un obstacle. Le capteur utilisé est le Ultrasonic Distance Sensor V2.0 de Grove : https://wiki.seeedstudio.com/Grove-Ultrasonic_Ranger/.
Ci-dessous, le code que nous avons utilisé pour tester le fonctionnement du capteur.
#include "Ultrasonic.h"

Ultrasonic ultrasonic(7);

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

void loop()	{
 long Range;
 bool A;
 Range = ultrasonic.MeasureInCentimeters(); // two measurements should keep an interval
 delay(250);
 if (Range > 30){
 A = 1;
 } 
 else{
 A = 0;
 } 
 Serial.print(A);
 if (A == 1){
 // code à ajouter en fonction du robot
 }
 else{
 // code à ajouter en fonction du robot
 }
} 

Conception esthétique
Pour la partie esthétique du robot, on choisit de réaliser une sorte de carrosserie à la maison, autour de l'idée d'un cornichon avec des ailes d'avion, sans aucune raison particulière.

Montage final

Pour le montage final, on a effectué des soudures au niveau des fils reliés au 2 moteurs puisque l'on a souhaité minimiser le plus possible les risques de déconnexions des fils. Egalement, on a finalisé le programme du robot. Selon nos instructions, il est supposé avancé de manière accélérée proportionnellement à l'intensité de la voix, et s'arrêter automatiquement lorsqu'il va rencontrer un obstacle. Le programme est le suivant :

#include "Ultrasonic.h"
#include <AFMotor.h>
int loudness;
int Range;

AF_DCMotor motor(1);
Ultrasonic ultrasonic(2);

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

 motor.setSpeed(200); 
}

void loop() {
 loudness = analogRead(0); 
 Range = ultrasonic.MeasureInCentimeters(); 
 Serial.println(Range);
 
 if (Range > 30){
 if ((loudness > 75) && (loudness < 200)) { 
 motor.setSpeed(255*loudness/200); 
 motor.run(FORWARD);
 delay(50);
 }
 
 else {
 motor.run(RELEASE);
 delay(50);
 }
 }
 
 else{
 motor.run(RELEASE);
 delay(50);
 }
}

Après plusieurs tests, et quelques réglages empiriques sur la sensibilité des capteurs de son, notre robot fonctionne. Les roues tournes correctement, et à une vitesse satisfaisante, lorsque l'on fait du bruit, et il s'arrête si un obstacle est situé devant lui.
On note toutefois 3 défauts :
- Il est nécessaire d'utiliser une rallonge pour connecter le robot à une prise secteur, et malgré ça, le robot reste volumineux
- Le robot ne peut pas détecter un obstacle s'il n'est pas directement en face de lui
- Le robot a parfois tendance à continuer à avancer après avoir arrêter de faire du bruit
Projets Personnel

Alex
Dessin et découpe laser des pièces d'un coffre à assembler
J'ai d'abord voulu utiliser un modèle trouvé en ligne de coffre à assembler. Ne trouvant pas de format compatible avec Inkscape, je suis partie d'une simple image des pièces du coffre par dessus laquelle j'ai redessiné une image vectorielle sur le logiciel. Mais après plusieurs burn tests, le modèle que j'avais choisi ne s'emboitait pas correctement. J'ai donc complètement redessiné mon propre modèle, disponible ici en format svg :

Coffre.svg
Attention, ce fichier est sur une seule page, mais il est trop grand pour rentrer sur les plaques utilisées au FabLab (600mm x 300mm), il a donc fallu le diviser en 2 fichiers et l'imprimer en 2 fois. Pour ça, j'utilise la Trotec Speedy 360. Il faut importer le fichier svg sur le logiciel du PC lié à la découpeuse laser, puis faire la "mise au point", sélectionner le bon matériau (ici du bois MDF 3mm) et lancer la découpe. Une caméra permet de vérifier en temps réel que la découpe se fera au bon endroit. Je reste ensuite à côté pour vérifier le bon déroulement du procédé. Une fois toutes les pièces obtenues avec succès, je les assemble avec une colle à bois (les instructions de montage sont données sur la page mentionnée quelques lignes plus bas, je ne les réécris pas ici car ce serait trop long pour peu d'intérêt). J'utilise des cure-dents pour les charnières, afin de relier le couvercle au reste du coffre. Ensuite,, je le décore avec de la peinture acrylique sur le bois, et au feutre POSCA (jaune et noir) pour repasser sur les gravures.

J'ai plus tard réutilisé ce modèle de coffre pour un projet personnel, dont les détails sont sur cette page : Coffres en bois. J'y rajoute quelques détails quant à la conception de ce premier modèle.

Conception et impression 3D de 2 modèles de "chien Minecraft"
Ce modèle 3D, composé d'un couple de chiens reprenant le design du jeu Minecraft, a été fait avec le logiciel FreeCAD. Le modèle "debout" a été créé en ajoutant différent parallélépipèdes les uns accolés aux autres, selon des dimensions trouvées sur des images internet, et avec une échelle un peu arbitraire (le but était que l'objet final fasse entre 5 et 10 cm). Il y a une simple rotation pour la queue. Le modèle "assis" est une copie du modèle "debout", auquel j'ai rajouté des rotations de différentes valeurs autour du même axe pour les pates et le corps, puis des translations sur ces mêmes parties de façon arbitraire, jusqu'à ce que le rendu finale me plaise, et de façon à ce que les 4 pattes reposent sur le même plan. Le fichier est disponible ici : Duo de chiens.stl

Il a ensuite été imprimé avec une imprimante du FabLab, avec du filament PLA blanc. Pour ça, on importe un fichier .stl (fichier 3D) dans le logiciel IdeaMaker, sur l'ordinateur connecté aux imprimantes 3D. On sélectionne l'imprimante, les paramètres d'impression (taux de remplissage, couleur du fil...), puis on lance l'impression. Pour ces 2 chiens, ça a duré environ 6h. Après avoir enlevé les supports générés automatiquement par le logiciel, le rendu final est conforme à mes attentes. Une des pattes s'est détachée pendant que je retirais les supports, mais elle a pu être recollée sans problème. J'ai ensuite décidé de peindre un des deux.

Angèle
Conception de coquetiers en 3DDans un premier temps, j'ai commencé par dessiner la forme d'un coquetier sur Inkscape. Puis j'ai coupé le dessin en 2 et je l'ai mis à la position (0;0), tout en haut à gauche de la page et enregistré au format svg.

   

Ensuite, j'ai importé le dessin sur Freecad, et j'ai utilisé la fonction Revolve pour créer un solide.

   

   

J'ai ensuite lancé l'application ideaMaker pour l'impression, où j'ai dupliqué le coquetier pour faire 3 exemplaires et paramétré mon impression. Ces coquetiers ne sont pas destinés à être utilisés pour l'alimentation, je les ai donc imprimé en PLA blanc.
coquetier.stl
Conception d'une maison à la découpeuse laser
J'ai dessiné sur Inkscape cette maison et entouré chaque face de créneaux pour l'assemblage.
Ces créneaux sont adaptés à un découpage sur du bois de 3mm, mais je n'y ai pas pensé au moment de choisir la planche, et j'ai utilisé du contreplaqué de 5mm. Le résultat m'a tout de même plu !Cependant, en raison de l'inclinaison du toit, il a fallu poncer un peu les créneaux pour qu'ils s'emboitent bien.

maison.svg

Louise
Conception et impression d'un "chien Minecraft" en 3D
Avec l'utilisation du logiciel OpenSCAD :
cube([28.125,18.75,18.75]);
translate([- 14,-3,0]) cube([14,24.75,21.75]);
translate([-24,0,0]) cube([10,18.75,18.75]);
translate([-34,5,0]) cube([10,10,10]);
translate([-17.5,0,18.75]) cube([3.5,6,6]);
translate([-17.5,12.75,18.75]) cube([3.5,6,6]);
translate([-9.5,10.75,-21]) cube([6,6,22]);
translate([-9.5,2,-21]) cube([6,6,22]);
translate([20,10.75,-21]) cube([6,6,22]);
translate([20,2,-21]) cube([6,6,22]);
rotate([0,60,0]) translate([-2,6.5,29]) cube([6,6,25]);
chien.stl

Ci-dessus le chien généré par le code.

Gravure d'une image
Afin de me familiariser avec l'utilisation de Inkscape et surtout de la découpeuse laser, j'ai commencé par simplement graver une image trouvée sur internet. Pour cela, il a d'abord fallut modifier l'image en dehors d'Inkscape, pour s'assurer que le contraste entre les parties claires et foncées soit optimal. Après cela, il ne restait qu'à coller l'image dans Inkscape et de l'entourer d'un rectangle rouge pour la découpe. J'ai de plus décidé d'ajouter un rectangle sur l'image, dans lequel j'ai écris "La Prophétie des Grenouilles" (titre du dessin animé dont est tiré l'image), pour me familiariser avec d'autres outils de l'application.
grenouilles.svg
Ci-dessous l'image originale et l'image modifiée pour avoir le meilleur contraste possible.

Après cela, il suffisait de lancer l'impression sur la découpe laser du Fablab, pour obtenir le résultat final :

Découpe 2D d'une lune en relief
Mon projet final pour la découpe laser était donc de fabriquer une lune en relief, c'est-à-dire composée de cercles qui viennent s'imbriquer autour de l'arc de cercle principal.
Pour cela j'ai, sur Inkscape, d'abord créé le corps principal de la lune en utilisant deux arcs de cercle collés ensemble. Il a fallut par la suite ajouter des encoches correspondant à l'épaisseur du matériaux utilisé (j'ai décidé de mettre 3,5cm pour un bois de 3cm mais ce n'était pas assez, il m'a fallu poncer après coup, l'idéal dans ce cas serait sans doute de 3,7cm). Puis, au niveau des encoches, mesurer la taille de l'arc de cercle avec l'outil règle d'Inkscape (cf. photo), ce qui nous donne le diamètre de chacun des cercles à créer. Une fois les cercles créer, il faut leur ajouter des encoches de la même taille qu'on avait mis au corps principal.

lune.svg
L'objet a ensuite été découpé sur une planche en bois suivant les trais rouges par la découpeuse laser du Fablab. Il ne restait plus qu'à l'assembler.
 

Alicia
Conception et impression de poignée de commode en 3D
Dans le cadre du projet personnel du Fablab, j'ai choisi d'imprimer des poignées de commode et un chien à l'aide du logiciel Openscad. Dans un premier temps, j'ai réalisé deux poignées de commode par l'association de cylindres et de sphères emboîtés. De plus, il a fallu créer un trou pour faciliter l'entrée d'une vis. Le projet étant simple, cela n'a pas été trop complexe à réaliser. Par la suite, j'ai repris le code de ma camarde Louise, afin de réaliser (ou du moins essayer) de faire un corgi :

Pour les poignées de porte, il fallait prendre en considération dans les paramètres, de l'utilisation quotidienne de ces dernières. Par conséquent, il faut les rendre résistante en augmentant le remplissage qui ici a été mis de 30%. Cependant, il n'y avait pas la couleur que je souhaitais dans l'imprimante 3D. J'ai donc dû remplacer moi-même le fil. Pour se fait, il fallait tout d'abord chauffer le fil déjà présent dans la machine jusqu'à une température souhaitée. Par la suite, on peut retirer le fil et incérer celui qui nous intéresse à l'intérieur de la machine. Il faut ensuite faire fondre une nouvelle fois faire chauffer le plastique souhaité et laisser l'imprimante 3D sortir le plastique ainsi fondu pour qu'elle retire les restes du fil précédent qui était resté dans l'imprimante.

Fichier de l'impression 3D :

chien et poignées de porte.scad
Le résultat a été très satisfaisant :

Projet découpe laser
Pour la découpeuse laser, j'ai choisi de faire des porte-clés en bois pour ensuite les donner à ma famille. Pour ce fait, j'ai utilisé le logiciel Inkscape pour dessiner le modèle : chat.svg

Pour réaliser la tête du chat, je me suis inspirée d'une image trouvée sur internet. Par la suite, je voulais m'assurer de la rigidité du porte-clés en choisissant un bois assez costaud.

Groupe A3 APaR 🌵

Informations pratiques :
Prénoms et NOMS: Alexandre TAUFFLIEB, Pola SZOPKA, Menouha Rachel LAHMI
Cursus : CMI Physique Groupe A

Timeline : S2 (2023)
Introduction au Fablab

Séance 1 : introduction au Fablab et au projet
Séance 1 : introduction au Fablab et au projet
Notre idée de projet est de créer un arroseur automatique utilisant un capteur d'humidité. Ainsi, l'objet créé pourra garder n'importe quelle plante ("classique") assez humide plus rationnellement qu'un arroseur automatique programmé exclusivement sur des horaires. Notamment, l'objet s'adapte aux saisons selon l'humidité de l'environnement de la plante et est donc plus adapté à la plante et à la quantité d'eau nécessaire à son évolution .Le système peut ainsi s'étendre à un ensemble de types de plantes plus large, avec un réservoir d'eau qui avertit l'utilisateur quand il est vide .
Capteurs Grooves utilisés :

Détecteur d'humidité dans le sol : Grove Moisture Sensor .
Détecteur de niveau d'eau dans le réservoir : Grove Water Sensor .

Séance 2 : Capteurs, et prototypage électronique
Séance 2 : Capteurs, et prototypage électronique

Capteur Arduino:

Image d'un Arduino assemblé à un Shield :

L'objectif est d'afficher la température et l'humidité de l'air sur l'ordinateur puis sur écran LCD grâce à une carte Arduino(+Shield) et à un capteur d'humidité et de température.
Pour commencer à utiliser un capteur d'humidité et de température (SHT31) grâce une carte Arduino, nous avons d'abord trouvé un programme et la librairie associée sur Wiki Seeed Studio et Github.
 Ces derniers nous permettent d'afficher les valeurs de la température avec la commande Serial Monitor en utilisant le programme suivant:
#include <Arduino.h>
#include <Wire.h>
#include "SHT31.h"
 
SHT31 sht31 = SHT31();
 
void setup() { 
 Serial.begin(9600);
 while(!Serial);
 Serial.println("begin..."); 
 sht31.begin(); 
}
 
void loop() {
 float temp = sht31.getTemperature();
 float hum = sht31.getHumidity();
 Serial.print("Temp = "); 
 Serial.print(temp);
 Serial.println(" C"); //The unit for Celsius because original arduino don't support speical symbols
 Serial.print("Hum = "); 
 Serial.print(hum);
 Serial.println("%"); 
 Serial.println();
 delay(1000);
}

Dans la console de l'IDE, l'ordinateur affiche par exemple les valeurs suivantes :
Temp = 24.77 C
Hum = 31.22%

Temp = 24.79 C
Hum = 31.30%

Temp = 24.76 C
Hum = 31.20%

Temp = 24.76 C
Hum = 31.09%

Temp = 24.73 C
Hum = 31.11%

Temp = 24.71 C
Hum = 31.05%

Temp = 24.71 C
Hum = 31.09%
On connecte ensuite l'écran LCD,  à la carte Arduino.

On trouve à nouveau la librairie associée sur GitHub pour l’écran LCD. Pour afficher les valeurs sur l'écran LCD, on s'est basé un programme de code pour afficher " Card Works " sur l'écran :
#include <Wire.h>
#include "rgb_lcd.h"
 
rgb_lcd lcd;
 
const int colorR = 255;
const int colorG = 0;
const int colorB = 0;
 
void setup() 
{
 // set up the LCD's number of columns and rows:
 lcd.begin(16, 2);
 
 lcd.setRGB(colorR, colorG, colorB);
 
 // Print a message to the LCD.
 lcd.print("hello, world!");
 
 delay(1000);
}
 
void loop() 
{
 // set the cursor to column 0, line 1
 // (note: line 1 is the second row, since counting begins with 0):
 lcd.setCursor(0, 1);
 // print the number of seconds since reset:
 lcd.print(millis()/1000);
 
 delay(100);
}
On a ensuite pu écrire et utiliser le programme suivant pour la carte Arduino :
#include <Arduino.h>
#include <Wire.h>
#include "SHT31.h"
#include <Wire.h>
#include "rgb_lcd.h"
 
rgb_lcd lcd;
 
const int colorR = 255;
const int colorG = 0;
const int colorB = 188;
SHT31 sht31 = SHT31();
 
void setup() { 
 Serial.begin(9600);
 while(!Serial);
 Serial.println("begin..."); 
 sht31.begin(); 
 // set up the LCD's number of columns and rows:
 lcd.begin(16, 2);
 lcd.setRGB(colorR, colorG, colorB);
 // Print a message to the LCD.
 lcd.setCursor(0, 0);
 lcd.print("Card works !");
 lcd.setCursor(1, 1);
 lcd.print(" (-^_^-) ");
 delay(5000);
}
 
void loop() {
 float temp = sht31.getTemperature();
 float hum = sht31.getHumidity();
 Serial.print("Temp = "); 
 Serial.print(temp);
 lcd.setCursor(0, 0);
 lcd.print("Temp = ");
 lcd.print(temp);

 Serial.println(" C"); //The unit for Celsius because original arduino don't support special symbols
 Serial.print("Hum = "); 
 Serial.print(hum);
 lcd.setCursor(0, 1);
 lcd.print("Hum = ");
 lcd.print(hum);

 Serial.println("%"); 
 Serial.println();
 lcd.setCursor(12, 1);
 lcd.print("%");

 delay(1000);
}

L'affichage a bien marché grâce à ce programme. On peut lire sur l'écran la température et l'humidité de l'air .

M5Stack Core ESP32

Programme « Hello Word » donnée en exemple par le constructeur :
/*
*******************************************************************************
* Copyright (c) 2021 by  M5Stack
*                 Equipped with M5Core sample source code
* Visit for more information: https://docs.m5stack.com/en/core/gray
* Describe: Hello World
* Date: 2021/7/15
*******************************************************************************
*/
#include <M5Stack.h>
/* After M5Core is started or reset
the program in the setUp () function will be run, and this part will only be run
once. */
void setup() {

   M5.begin();        // Init M5Core.

   M5.Power.begin();  // Init Power module.

   /* Power chip connected to gpio21, gpio22, I2C device

     Set battery charging voltage and current

     If used battery, please call this function in your project */

   M5.Lcd.print("Hello World");  // Print text on the screen (string)
}

/* After the program in setup() runs, it runs the program in loop()
The loop() function is an infinite loop in which the program runs repeatedly */
void loop() 
{
Le programme fonctionne , « Hello World »apparaît à l’écran .

Pour afficher la température et l'humidité sur l'écran du M5Stack, nous avons dû retrouver le programme en utilisant Chat GPT (Programme original perdu et contrainte de temps). Voici le code ainsi obtenu:
#include <M5Stack.h>
#include <DHT.h>

#define DHTPIN 36 // Pin du capteur DHT
#define DHTTYPE DHT11 // Type de capteur DHT

DHT dht(DHTPIN, DHTTYPE);

void setup() {
 M5.begin();
 dht.begin();
}

void loop() {
 float temperature = dht.readTemperature(); // Lecture de la température
 float humidity = dht.readHumidity(); // Lecture de l'humidité
 M5.Lcd.fillScreen(BLACK); // Effacement de l'écran
 M5.Lcd.setTextSize(3); // Taille du texte
 M5.Lcd.setTextColor(WHITE); // Couleur du texte
 M5.Lcd.setCursor(10, 10); // Position du texte
 M5.Lcd.printf("Temp: %.1f C", temperature); // Affichage de la température
 M5.Lcd.setCursor(10, 60); // Position du texte
 M5.Lcd.printf("Humidite: %.1f %%", humidity); // Affichage de l'humidité
 delay(2000); // Attente de 2 secondes
}

Le programme original fonctionnait : on peut lire sur l’écran la température et l’humidité de l’air.

Malheureusement, lorsque nous avons écrit notre premier programme, les emplacements de texte n'avaient pas bien été paramétrés et les mesures s'affichaient en tout petit et tendaient à se superposer. Toutefois, le programme ci-dessus prend quand à lui déjà en compte la taille des caractères et leur emplacement et, donc, en l'utilisant les données devraient s'affichaient plus grandes et bien une en dessous de l'autre .

Séance 3:Dessin 2D 3D ,Impression 3D ,Découpe Laser
Séance 3:Dessin 2D 3D ,Impression 3D ,Découpe Laser

Dessin 2D : Inskcape

Ce logiciel permet de dessiner en 2D afin de réaliser une découpe /gravure laser. Des formes que nous pouvons transformer et utiliser à notre guise sont déjà proposées par le logiciel. Il suffit de le paramétrer selon ce qu'on cherche à dessiner. Le rouge est destiné à la découpe et le noir à la gravure (Attention à bien suivre les conventions !). Nous avons ainsi pu dessiner une petite tête de Robot :

Modélisation 3D :

Open SCAD

Ce logiciel peut être utilisé pour modéliser un objet en 3D . Ce logiciel fonctionne de la manière suivante, il suffit d’entrer un code pour une forme particulière que l’on souhaite dessiner en 3D (cela fonctionne aussi pour les objets en 2D )pour que le logiciel la dessine. On peut trouver ce code sur : https://openscad.org/cheatsheet/ .On peut ainsi dessiner un cube, par exemple .Dans notre cas nous avions pour objectif de dessiner un cube trouée sur ses 6 faces .Pour cela il suffit d’entrer le code du cube puis de faire une différence avec 6 petits cylindre placés au centre de chacune des 6 faces .

Voici le code utilisé ,suivi de la figure qu’il a permit de construire .
difference(){
 cube(50, center = true);
 union(){
 cylinder(60, 5, 5, center = true);
 rotate ([90,0,0]) cylinder(60, 5, 5, center = true);
 rotate ([0,90,0]) cylinder(60, 5, 5, center = true);
}
}

FreeCAD

Voici un second logiciel de modélisation 3D .Contrairement à OpenScade , ce logiciel ne fonctionne pas avec des codes qu’il faut importer d’un site externe. Le logiciel lui-même propose des formes prédéfinies que nous pouvons utilisés à notre guise pour former l’objet que l’on souhaite .
Comme précédemment notre mission consistait à dessiner un cube trouée sur ses 6 faces. Pour cela il suffisait en premier lieu de sélectionner notre cube puis de le trouer en utilisant l’option Cut (toutes les informations sont indiquées sur les images ci-dessous )

Option Cut ou Soustraction :

Pour centrer notre cylindre(qui fera office de trous) au centre des surfaces du cube :Régler la position( ou sa taille) de celui-ci en cliquant sur le cylindre dans l'onglet applications à gauche .Les paramètres s’afficheront et il sera possible de réaliser les modifications voulues . Pour plus de paramètres cliquer sur l’option tâches de la fenêtre .

Voici notre objet achevée et son suivi de conception à gauche sur la fenêtre .

Projet :

Séance 4 : Conception du projet Arroseur de plante
Séance 4 : Conception du projet Arroseur de plante

Matériel nécessaire :

Détecteur d'humidité dans le sol
Détecteur de niveau d'eau )
Pompe à eau
Relais
M5 STACK

Carte Arduino

Ecran OLed 128 X 62

Test capteur humidité

Pour connaître les valeurs que le capteur d'humidité dans le sol enregistre selon l'arrosage d'une plante, on a créé un programme Arduino pour prendre les données. On a ensuite inséré au programme des valeurs seuils à partir desquelles l'arroseur automatique devrait se mettre en route .(car plante trop séche).

Séance 5 : soudure et test de la pompe
Séance 5 : Soudure et Test de la pompe

Soudure de la pompe :
La première pompe que nous avions l'intention d'utiliser n'avait pas de terminaisons adaptées pour la connecter au relais .Il a fallut la souder à des câbles adaptés.

Pour réaliser la soudure ,Il faut au préalable découper un peu de l'isolant sur les câbles auxquels on voudrait connecter le relais puis lui rajouter de l'étain fondu à l'aide du fer à souder. Prendre des câbles du pont et de la même façon leur découper un peu de l'isolant, puis leur rajouter de l'étain. Souder le tout à l'aide du fer à souder. Enfin ,rajouter de la gaine thermo rétractable pour isoler le tout.

Test de la pompe :

Pour connaître les fonctionnalités et propriétés de la pompe nous nous sommes documenter sur Seeed Studio. Afin de bien tester le fonctionnement de la pompe nous l’avons brancher à une alimentation de 3 V environ. Pour notre pompe, il faut l'activer 1 minute pour avoir 100 ml.
void setup() {

 pinMode(4, OUTPUT);
}

void loop() {

 digitalWrite(4, HIGH);

 delay(10000);

 digitalWrite(4, LOW);

 delay(10000);
}
Voici les tests de la pompe en cours de réalisation .
Nous avons utilisé une bredboard pour faciliter les branchements lors des tests et le tuyau utilisé ci-dessous diffère de celui utilisé finalement .

Séance 6: Changements drastique du projet
Séance 6: Changements drastique du projet

Lorsque nous avons réfléchit au réservoir allant avec l'arroseur automatique, nous avons essayé de le concevoir et de l'imprimer en 3D.
Impression 3D du réservoir :
Nous avons conçu notre modèle  de réservoir sur FreeCad en suivant le mode de fonctionnement du logiciel comme appris précédemment (Séance 3).
Pour l'impression du réservoir, il faut au préalable exporter notre fichier de FreeCad au format STL car sinon le logiciel d’impression IdeaMaker ne reconnaît pas le fichier. Nous nous sommes servi(e)s du wiki pour avoir une bonne connaissance du fonctionnement de l’imprimante et du logiciel associé dans la section tutoriel. On imprime le réservoir d'eau sans le couvercle : ces deux parties ont été séparées avec l'outil cut.

Voici notre réservoir réservoir modélisé grâce à FreeCad :

Nous avons donc tenté d'imprimer grâce au logiciel Idea-Maker notre réservoir en deux parties distinctes en l'important donc au format STL sur l'ordinateur de la salle des imprimantes .
Voici la forme attendue et simulée sur Idea-Maker pour le bas de notre réservoir .

Avant de lancer l'impression, nous avons paramétré notre impression afin de lui accorder les supports nécessaire à une impression favorable et optimale ainsi que lui configuré l'épaisseur, la densité de remplissage de l'objet  et le motif d'impression souhaité.

Nous avons ensuite cherché une imprimante disponible et y avons ajouté du fil de la couleur que l'on souhaité :

Avant de lancer l'impression , nous l'avons simulée afin de vérifier les supports :

En dépit de tous nos efforts, notre impression a raté pour des raisons inconnues. On peut expliquer cet échec par la complexité et le nombre important de vide dans notre objet ce qui complexifiait son impression .

Réservoir en PMMA

Après l'échec de l'impression 3D du réservoir et en vue du temps restant pour présenter notre projet. Nous avons décidé de simplifier quelques aspects du projet. Le réservoir d'eau prévu sera destiné à une plante du Fablab qui possède déjà un pot ,cela nous éviter de perdre le temps d'en concevoir et tenté d'imprimer 1.
Ci-dessous, la plante à laquelle sera dédiée notre arroseur :nous l'avons nommée Emeline. Le pot fait 13,5 centimètres de diamètre. Le réservoir est de 18,5 centimètres en largueur et en longueur. Pour pouvoir dès à présent le construire, nous avons pensé un réservoir carré qui sera calé sur le pot : la face haute du réservoir tient sur le pot. Le réservoir est en PMMA. Nous avons déjà découpé dans l'atelier l'extérieur de ce premier:

A la prochaine séance, nous découperons le reste de la structure de notre réservoir afin de l'adapter selon les pièces électroniques qui seront utilisés : ainsi si certaines pièces ont besoin d'être abriter de l'eau, le couvercle pourra être ajusté pour laisser passer les fils des appareils.

Programme complet final de l'Arduino
Nous avons pu grâce à tous les tests effectués et ayant tous le matériel à notre disposition écrire le programme quasi final(il manque la partie du capteur de niveau d'eau ) de notre carte Arduino et ainsi programmer notre arroseur . En langage naturel, nous voulons que le code opère plusieurs opérations. Nous avons ensuite utilisé Chat GPT pour traduire le code du langage naturel en code C. Des modifications ont été effectué sur celui-ci.

mesurer le niveau d’eau du réservoir avec le Watersensor
si le réservoir est vide : 
	faire clignoter le LCD en rouge
sinon :
	mesurer le niveau d’humidité 
	si le niveau d’humidité de la plante est en dessous de 400:
 ouvrir le relai
 attendre 30 secondes 
 fermer le relai
refaire le programme toute les 24h
const int waterSensorPin = A0;
const int relayPin = 2;
const int ledPin = 3;

void setup() {
 pinMode(relayPin, OUTPUT);
 pinMode(ledPin, OUTPUT);
 Serial.begin(9600);
}

void loop() {
 int waterLevel = analogRead(waterSensorPin);
 if (waterLevel < 200) {
 // Si le réservoir est vide, faire clignoter la LED rouge
 blinkRedLED();
 } else {
 // Si le réservoir n'est pas vide, mesurer le niveau d'humidité
 int humidityLevel = analogRead(A1);
 Serial.println(humidityLevel);
 if (humidityLevel < 400) {
 // Si le niveau d'humidité est faible, ouvrir le relai, attendre 30 secondes et fermer le relai
 digitalWrite(relayPin, HIGH);
 delay(60000);
 digitalWrite(relayPin, LOW);
 }
 }
 // Refaire le programme toutes les 24 heures
 delay(86400000);
}

void blinkRedLED() {
 digitalWrite(ledPin, HIGH);
 delay(500);
 digitalWrite(ledPin, LOW);
 delay(500);
}

Nous avons également effectué des tests sur ce code pour vérifier qu'il programme notre arroseur comme voulu .
Pour cela ,il a fallut que l'on relie tous les composants entre eux et que l'on réalise le circuit électronique final de notre arroseur .
Voici tous nos composants connectés à l'Arduino, les composants non indiqués sur l'image ci-après n'ont pas été utilisés.

Nous avons ainsi pu simuler tester avec deux tasses pleines d'eau, le fonctionnement de notre arroseur automatique :

Le fonctionnement est opérationnel : Lorsque le capteur d'humidité estime que l'humidité est trop basse il communique l'information au relais qui lui active la pompe qui s'actionne et dans notre cas pratique fait passer l'eau d'une tasse à l'autre .La LED s'allume simultanément en vert .

Séance 7 : Soudures
Séance 7 : Soudures
La première pompe que nous avons soudée précédemment n'était pas très adaptée au fonctionnement de notre réservoir on a donc opté pour un autre modèle :
Nous avons du ressouder ses terminaisons à des câbles plus adaptés .

La voici reliée au relais

Durant cette séance nous avons également finalisé toute la partie électronique de notre projet en réalisant des derniers tests .

Séance 8 : Collage et gravure
Séance 8 : Collage et gravure

Durant cette séance ,nous avons poursuivi la "construction de notre réservoir".
Collage
Nous avons coller les morceaux de Plexi découpés lors des dernières séances. Dans la première photo, ceux sont les faces intérieures qui ont été collées et scotchées autour d'un morceau de polystyrène découpé à cet usage. Dans la deuxième photo, ceux sont les face extérieures qui ont été de même collées et fixées. Ce travail a été fait avant la séance.

Pour le collage, nous avons utilisé comme colle du PMMA dissolu dans de l'acétone. Ainsi, lorsque l'acétone sèche, il ne reste que du PMMA entre les parois. Le temps de pose pour le collage est un peu long ( 6H ) mais le résultat est très satisfaisant. La structure est solide et après avoir coller les faces extérieures, intérieures et la base du réservoir, le test d'étanchéité a été réussi. Il y eu seulement un coin à corriger mais la colle empêche bien l'eau de passer.

Pour pallier aux problèmes d'étanchéité nous avons renforcé les liens entre nos différentes planches avec de la colle forte:
Notre réservoir est ainsi étanche :

Il ne reste plus qu'à ajouter le couvercle du réservoir .
Gravure pour la boîte de l'arduino
Nous avons voulu personnalisé notre Projet en nommant notre plante et en lui créant une boîte pour l’arduino qui se ferme avec une gravure par dessus indiquant le nom de notre plante ,un logo du Fablab de Sorbonne Université ainsi que nos noms .
Nous avons dessiné un petit design de feuille sur Procreate :

Nous l’avons vectorisé sur Inskcape , puis rajouter le nom de notre plante . Voici le résultat: 

Nous l’avons ensuite graver et découper sur le couvercle de notre boîte pour l'Arduino. Nous y avions également noter nos noms mais malheureusement ceux-ci ne sont pas très bien gravés. Voici le couvercle final gravé:

Nous nous sommes ensuite rendu compte que la boite était trop petite pour contenir l'arduino et la pompe et qu'il était plus efficace de les placer dans la même boite et le matériel utilisé ne correspondait également pas au bon ce qui a endommagé notre gravure :

Nous avons ainsi redimensionner notre boite et utiliser le bon matériel  :

Nous avons procédé de la même manière que précédemment :

Séance 9 : Montage du réservoir
Séance 9 : Montage du réservoir

Programme final du réservoir : (le temps au bout duquel le mécanisme se réactive est mis a 1s pour des raisons de démonstration, mais la valeur conseillé pour une utilisation réelle est de 24h, la valeur en millisecondes est indiqué dans les notes entre parenthèses)
// Librairies pour fonctionner la barre de LED
#include "Adafruit_NeoPixel.h"
#ifdef __AVR__
#include <avr/power.h>
#endif

//Toutes les constantes utilisés dans le programme
#define EAU A1
#define RELAIS A3
#define LED A0
#define HUMIDITE A2
#define TEMPS 10000 // temps au bout duquel le mécanisme se réactive (86400000)
#define TEMPS_RELAIS 30000 // temps d'ouverture du relais en ms 1min <=> 100 mL d'eau

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(10, LED, NEO_GRB + NEO_KHZ800);

//Fonctions utilisés dans le programme
void LED_verte() { //Allumer la barre de LED en vert
 for (int i = 0; i < 10; i++) {
 pixels.setPixelColor(i, pixels.Color(0, 255, 0));
 pixels.show();
 }
}

int LED_rouge(int temps){ //Faire clignoter la barre de LED en rouge
 for (int j = 0; j < (temps / 1000); j++) {
 
 for (int i = 0; i < 10; i++) {
 pixels.setPixelColor(i, pixels.Color(255, 0, 0));
 pixels.show();
 }
 delay(500);

 for (int i = 0; i < 10; i++) {
 pixels.setPixelColor(i, pixels.Color(0, 0, 0));
 pixels.show();
 }
 delay(500);
 }
}

//Programme principal
void setup() {
 pinMode(RELAIS, OUTPUT);
 digitalWrite(RELAIS, LOW);
 
 pixels.setBrightness(255);
 pixels.begin();
}

void loop() {
 int niveau_eau = analogRead(EAU);

 // Si le réservoir est vide, faire clignoter la LED rouge
 if (niveau_eau > 800) {
 LED_rouge(TEMPS);
 
 } 

 // Si le réservoir n'est pas vide, mesurer le niveau d'humidité
 else {
 LED_verte();
 int niveau_humid = analogRead(HUMIDITE);
 
 // Si le niveau d'humidité est faible, ouvrir le relai, attendre TEMPS_RELAIS et fermer le relai
 if (niveau_humid < 400) {
 digitalWrite(RELAIS, HIGH);
 delay(TEMPS_RELAIS);
 digitalWrite(RELAIS, LOW);
 delay(TEMPS - TEMPS_RELAIS) ;
 }
 }
}

On a collé le couvercle du réservoir pour avoir notre réservoir complet :

On as placé le capteur d'eau dans le réservoir, qu'on cale avec de la colle chaude :

On as fini d'étanchéifier, le réservoir avec de la colle chaude.

Des dernières impressions 3D, on été réalisé pour améliorer le projet. Il s'agit d'un entonnoir pour améliorer le versement de l'eau dans le réservoir, et d'une partie pour aider le tuyau à se planter dans le sol.
Le projet est donc finie :

Fichier gravure de la boite a partir d'un générateur de boite (https://www.festi.info/boxes.py/ClosedBox?language=fr )
ClosedBox.svg

Séance 10 : Fin du projet
Voici notre dispositif final :

Lien vers la présentation du projet (il est impossible d'importer la présentation) :
https://docs.google.com/presentation/d/1RvjZwm3ub1IRcP89UrX1iEL7PhEK4Pk01iP4Ofjxdcw/edit?usp=sharing

Projets personnels :

Projet perso Pola
Projet Perso : Pola
Projet 2D :

Objectif

Modéliser en 2D et graver une plaque de contreplaqué pour obtenir un peigne à tisser.
Modélisation

Fichier final :

metier-a-tisser.svg

Gravure du bois

Bonus : au cœur de l'action .

Projet 3D :

Objectif

Modéliser puis réaliser un organisateur d’aiguilles à tricoter. ( Sachant qu'il y as 5 aiguilles de 2 mm de diamètre, 10 aiguilles de 2,5 mm de diamètre, 5 aiguilles de 3 mm de diamètre, 5 aiguilles de 3,5 mm de diamètre et 5 aiguilles de 4 mm de diamètre). Le séparateur sera ensuite collé sur une plateforme avec des trous pour pouvoir être cousus sur une pochette, pour rendre le tout pratique.
Modélisation

organisateur.stl

Impression 3D

Projet Perso Menouha Rachel
Projet Perso Menouha Rachel
Projet 2D
Objectif

Modéliser en 2D ,graver un logo et ajouter des designs personnels à graver puis découper grâce à la découpe laser sur une planche en bois pour une décoration de bureau .
Modélisation 2D
Logiciel utilisé :Inkscape
J'ai décidé de graver un logo d'une série télévisé que j'aime beaucoup .J'ai copié une image du logo en question .
Voici sa source : https://ih1.redbubble.net/image.1175253289.6955/bg,f8f8f8-flat,750x,075,f-pad,750x1000,f8f8f8.u1.jpg

Pour modéliser mon image et pouvoir la graver il faut tout d'abord la copier-coller dans une page Inkscape.

Une fois l'image copié cliquer dessus et sélectionner  "Vectoriser un objet matriciel"

Ensuite ,sur la fenêtre de gauche on a nos paramètres de vectorisation pour notre image qui s'affichent .

Pour bien vectoriser notre image ,j'ai effectué quelques modifications dans les paramètres comme indiqué dans l'image ci-dessous:

Je n'ai à présent plus qu'à appliquer la vectorisation de l'image :

Pour finaliser la vectorisation ,suivre les indications sur l'image ci-dessous:

J'ai ainsi obtenu mon image vectorisée :
En cliquant dessus et en sélectionnant l'option fonds et contours  une fenêtre pour régler les paramètres de mon image s'affiche à droite .

Pour régler l'épaisseur de mes contours :

Afin d'ajouter une touche personnelle à ma gravure j'ai décidé d' y ajouter une petite spirale .
Voici comment j'ai procédé :

J'ai décidé ensuite de graver en bas à droite de mon cadre le prénom de ma petite sœur pour lui offrir la décoration finale .
Voici comment j'ai procédé :

J'ai ainsi obtenu ma modélisation 2D.
Voici le fichier au format svg  :

Découpe +Gravure à la découpe laser

J'ai tout d'abord coller mon image sur le site Trotec Ruby .

J'ai ensuite trouver du bois dans les chutes  pour découper et graver mon design: J'ai positionné mon bout de bois dans la découpe laser .
J'ai ensuite cadrer ma modélisation sur la plaque de bois simuler sur l'ordinateur :

J' ai ensuite bien placer la sortie du  faisceau de l'appareil comme indiqué ci-dessous:

Voici la découpe Laser en action :

J'ai réussit à obtenir ma décoration !Voici ce que Ça a donné !

Projet 3D
Objectif

Concevoir puis imprimer un mini piano en 3D .
Logiciel utilisé: Tinkercad (sur Ipad)
Le logiciel est très performant et sur iPad les réglages sont rapides, car à l'aide de l'Apple Pencil et de l'écran tactile on peut facilement manier les formes et objets à notre guise afin de concevoir ce qui nous intéresse .
Modélisation 3D
Pour commencer ma création ,j'ai utilisé deux cubes dans les formes simples proposées par l'application puis je les ai réglées afin qu'elles forment les deux blocs de base de mon piano .

J'ai ensuite rattaché les deux blocs afin que mon objet ressemble plus à un piano .
J'ai également ,en utilisant encore une fois un cube réalisé la première pédale de mon petit piano :
Voici ce que ça a donné :

Afin de ne pas perdre de temps à refaire deux autres pédales j'ai utilisé l'option collage comme expliqué dans l'image ci-dessous :

J'ai obtenu ceci:

J'ai ensuite vidé mon cube noire servant de support au clavier du piano afin de pouvoir créer les touches de mon piano et les y placer :
Pour cela je me suis servie de l'outil vider un élément :

J'ai obtenu ceci :

J'ai ensuite commencé à réaliser mon clavier :
Pour cela j'ai créé des blocs de touches blanches que je copiais collais un à un en les sélectionnant en bloc .

Pour déplacer et modifier la taille et le position des éléments il suffit de se servir des petites flèches qui s'affichent autour de notre objet quand on le sélectionne .

J'ai procédé de la même manière pour les touches noires .

J'ai ainsi obtenu mon clavier :
J'ai également ajouté 2 cubes pour les bords de mon piano :

Me rendant compte que le cube vidé rendait difficile mes manipulations avec l'Apple Pencil j'ai pensé qu'il serait plus simple d'utiliser simplement  un support de clavier noire à l'aide d'un cube que j'ai aplati :
J'ai ensuite rallier le clavier au piano :
Voici le résultat final de ma conception 3D:

Voici mon modèle au format Stl:
"D:\Piano.impression 3D.stl"

Impression 3D

J'ai tout d'abord exporté mon fichier au format stl puis enregistrer sur ma clé USB :
Le voici ci-joint :
J'ai branché ma clé à l'ordinateur de la salle d'impression 3D .
J'ai ouvert mon fichier dans le logiciel Idea Maker :

Imprimer l'objet ainsi risque de ne pas bien fonctionner du aux supports nécessaires :
J'ai décidé de le renverser afin que moins de support soit nécessaire :
Pour cela ,j'ai utilisé l'outil rotation :

J'ai ensuite configuré les paramètres de mon impression afin de régler la hauteur de couche ,le pourcentage de remplissage ...de mon objet :

J'ai ensuite décidé d'estimer le résultat de mon impression :

J'ai ensuite choisi une imprimante ,sélectionné un fil que j'ai choisi (orange )et j'ai lancé mon  impression :
Voici l'imprimante en action :

Voici mon objet finalement imprimé :

Projet perso Alexandre :
Projet perso Alexandre :

Découpe 2D en bois

L'objectif est de modéliser sur FreeCAD plusieurs pièces simples qui en s'assemblant puissent servir de support pour ordinateur ou pour un livre comme un manuel. Les différentes pièces sont modélisées en 2D pour être découpées en bois. Pour pouvoir modéliser en 2D sur FreeCAD, je me suis aidé d'un tutoriel en ligne.
Pour la première étape, j'ai commencé par le plus évident en mesurant la taille de mon ordinateur en largeur et en longueur que j'ai respectivement arrondi vers le haut à 25cm et 35cm pour le support. Ainsi, il me reste de l'espace sur le support pour le lier au reste de la structure par la suite.

Ce support se glisse sur les côtés de la structure. Sur le mode Draft, on peut dessiner des formes avec des lignes qu'on peut ensuite lier par la fonction Wire (upgrade) dans le mode Part. Les côtés rehaussent l'ordinateur d'environ 6cm à un angle de 10°. Pour vérifier que le support rentre dans les côtés, on modélise un rectangle qui représente le support vu de côté (donc de dimension 1cm de hauteur et 25cm et quelques de largeur).

Dans Part, on peut ainsi créer une surface avec les Wires à laquelle on soustrait (cut) le rectangle pour créer l'espace où le support sera glissé.

Pour modéliser une structure plus solide, on peut créer des rectangles de 1cm par 1cm (Draft) et les associer au côté en les espaçant de 1cm chacun. La fonction Compound permet d'accélérer cette étape en groupant plusieurs rectangles ensemble. Le but est d'utiliser le même motif de rectangles sur ce qui servira comme base du support.

Ainsi en utilisant la fonction Cut dans Part, les trous dans la base du support seront exactement les mêmes que ceux utilisés dans les côtés de la structure. Ce modèle d'assemblage est utilisé par Maker Box pour créer des structures de boîte fonctionnelles. La base du support est longue de 35cm (comme le support) et est large de 29,5cm comme les arrêtes à dent des côtés.

Pour créer la pièce qui bloque l'ordinateur/livre sur le support, il suffit d'utiliser un rectangle (ici 20cm de longueur et 2,5cm de largeur) auquel on soustrait un motif de rectangles comme ceux utilisés précédemment.

On soustrait ensuite ce même motif de rectangle au support. En ajoutant quelques millimètre de marge, l'assemblage des deux pièces pourra être fonctionnel.

La modélisation sur FreeCAD est prête.

Voici le rendu final après la découpé Freecad m'a joué des tours, des ajustements sur la structure ont dû être fait mais sinon le principe reste le même.
Au lieu d'avoir la base de l'ordi qui se glisse dans les deux autres planches, celle-ci s'emboîte dans les deux équerres sur le côté. J'ai aussi rajouter deux planches qui s'emboîtent avec les deux équerres pour rajouter de la stabilité à l'objet. J'ai aussi rajouter de la colle chaude pour remplir les trous.
Impression 3D

Mon projet en 3D est de modéliser un plectre/médiateur. Cet objet a 4 courbes et n'est en fait pas si évident à réaliser mais voici comment j'ai fait.
Tout d'abord, j'ai utilisé un cercle de 5 cm de rayon, ce sera la hauteur du plectre.

Ensuite, j'ai utilisé des tubes de la même hauteur que mon cercle pour découper la forme du plectre. Avec l'option cut, cette partie se fait facilement. Les tubes sont placés symétriquement par rapport à l'axe x pour que le plectre soit lui aussi symétrique. Les tubes ont bien sûr la même dimension.

Le cut crée malheuresement des coins pointus donc il faut les adoucir avec la fonction fillet. Pour ça, il suffit de sélectionner l'objet sur lequel on utilise le fillet puis quelle arrête sera arrondie. Le diamètre doit être grand si l'on veut éviter des bosses sur les coins.

Après toutes les opérations, nous avons la base du plectre, mais celle-ci est plutôt fine( 1 mm ) et nécessite deux couches en plus pour ajouter de la densité.

Pour faire la couche supplémentaire, on peut utiliser des formes géométriques et les assembler. Encore une fois, il faudra adoucir les coins avec la fonction fillet. Ici, j'ai utilisé un cercle et trois rectangles. La couche supplémentaire peut être copiée et collée juste en dessous du plectre pour que son épaisseur soit de 3 mm au moins. Il faut pour cela créer un compound avec les figures géométriques utilisées.

Pour l'impression, il faudra prendre soin de sélectionner une épaisseur assez importante pour éviter toute casse du plectre (surtout en vue du support qu'il y aura).

Voici le résultat final !

Malheureusement, les dimensions surtout la hauteur ne sont plus homogènes à l'impression. Cependant, le plectre fonctionne et ne casse pas, finalement cela le rend plus joli !

🎛️  UE 5Ci803 - Optimisation et contrôle des procédés



Aquarium et régulation de la qualité de l'eau

Informations

Camille Guillet, Amel Gaci, Sabrina Akour, Andjela Zlatkovic, Anis Sakka
email : camille.guillet.2@etu.sorbonne-universite.fr

UE 5CI803
15/12/2022 - 31/01/2023

Contexte
Nous cherchons à effectuer la régulation et le contrôle de la qualité de l'eau d'un "aquarium " dans le cadre de notre UE 803 'optimisation et contrôle des procédés.
Objectifs
- construire un aquarium avec les outils à disposition
- Réaliser une régulation de la qualité de l'eau : contrôler la turbidité, le niveau d'eau et la température
- Mettre au point et Réaliser un dispositif expérimental et un schéma electronique avec Arduino

Vue filaire de notre aquarium avec les cloisons incorporées

Vue ombrée de notre boîte d'aquarium
Matériel

2 planches de CP peuplier 5mm (dimensions 280*580mm)
Plexiglas
Silicone
Capteur Turbidité et niveau eau
Pompes eau et pompe air
Tuyaux
Sonde de Température immergeable
elctrovanne, servomotor
Switch A/N, cables, adaptateur 12V

Machines utilisées
- Découpe Laser
- pistolet à colle
Construction
Étape 1
Construction du bocal Aquarium : utilisation logiciel découpe laser
Étape 2
Construction support en bois : découpe planche et gravure 
Étape 3
Réalisation montage electronique (Arduino)
Étape 4 :
finalisation aquarium : collage (avec colle pour Glue, mais mieux d'utiliser colle PMMA acrylique pour Plexiglas) , joints de colle ( ça aurait été mieux avec des bons joints de silicone) installation des pompes et vannes, tuyaux
Étape 5 :
Code Arduino et test electronique
Étape 6 :
Installation finale:  réservoir source et évacuation eau et tests
Étape 7 :
Démonstration
Journal de bord
15/12/2022
Brainstorm et définition des dimensions du bocal: 25  x 20 x 15 (cm) et matériau (Plexiglas) : transparent, résistant au poids de l'eau et suffisamment inerte, d'épaisseur 3mm.
Utilisation logiciel Festi pour générer les dimensions de la boite
16/12/2022
Utilisation outil découpe laser et assemblage plaques Plexiglas : début de construction aquarium
03/01/2023
Brainstorm sur la filtration et agencement des outils et dispositifs
Code pour Arduino : début
Découpe planche bois pour support et gravure
Poursuite construction de l'aquarium
06/01/2023
Codage Arduino
Début Montage composants électroniques
09/01/2023
Montage electronique, Arduino: branchages 
chaque pompe est contrôlée par un relai 5V:  les pompes sont alimentées par un courant de 12V (air et eau) ou 3V pour la pompe immergée. Les capteurs sont reliés à du 5V : le capteur de turbidité a une sortie analogique (reliée à A0), celui de niveau d'eau digitale ( relié à un pin 8). La ligne d'alimentation du bas de la platine d'essai est réalisé par  le microcontroleur en 5V, et permet d'alimenter les capteurs et les relais. La 2ème ligne d'alimentation est alimentée en 12V par un adaptateur 12 branché sur secteur. L'alimentation de la pompe immergée en 3V est réalisé par l'alimentation du controleur via une autre platine d'essai
Collage, Joints de la boite de l'aquarium : début des joints : à poursuivre : les dimensions des 2 parois de Plexiglas séparant les compartiments sont de même dimension mais les plaques de Plexiglas ne sont pas placées au même niveau : 
h x l x e : 11cm x 19,6 cm x 3mm
Agencement des différentes parties, scotchage
17/01/2023
Avancement montage electronique

20/01/2023
réalisation 2ème planche CP Peuplier, mise en place des tuyaux, test des diamètres d'installation du capteur niveau d'eau
24/01/2023
Détermination du diamètre trou capteur d'eau d=21,3mm et de la position : environ 12,5 cm depuis le bas , plus ou moins vers le 1er tiers de la longueur. 
Collage des bords de l'aquarium, sauf dernière avec le trou, problème de collage et assemblage (changement de colle entre les 2) : on n'a pas réussi à bien tout assembler de manière jointive. En voulant arranger le problème, (on a voulu enlever la plaque collée très fortement) on a cassé la plaque. Donc, refabrication de la même plaque la fois d'après.
Les cloisons entre les compartiments sont au nombre de 2 ( mêmes dimensions, cf 09/01)
Une 1re cloison séparant le bac principal ( Aquarium) et le compartiment de "filtration" : cette plaque est collée de la base (20 x 20 cm) de l'aquarium, perpendiculairement aux 2 parois longitudinales ( parallèlement à la paroi latérale)  par la tranche de 3mm: cette plaque de 11cm permet le débordement de l'eau par dessus la plaque pour passer sur le filtre à café installé. Elle est installée à partir de 3,5 cm environ de la paroi latérale de l'aquarium.
Une 2ème cloison est également installée parallèlement à 2cm de la première et à 1,2 cm  environ de la paroi latérale de l'aquarium. celle ci est collée de telle manière que le haut de la paroi est à  15cm de haut : il y a donc h1=15-11-0,3=3,7 cm d'espace entre la base de l'aquarium et la cloison. Celle ci permet de séparer l'espace "filtration" et l'espace de pompage/évacuation de l'eau. La plaque est donc collée sur 2x11 cm sur les parois latérales.
Le filtre à café sera installé à la toute fin entre ces 2 "cloisons" pour permettre à l'eau transvasante et de se déverser dessus et de la filtre : l'eau s'écoule du haut vers le bas et l'eau en aval du filtre est donc filtrée et évacuée par la pompe à eau (le filtre permet d'éviter de boucher les tuyaux et la pompe)
26/01/2023
Fabrication d'une nouvelle plaque plexiglas pour la dernière paroi de l'aquarium, assemblage pas jointif encore avec le test de colle. On a finalement juste pris de la colle pour faire des joints d'étanchéité et pour boucher un peu les trous de la dernière longueur. Pour les fuites, on mettre notre boite d'aquarium dans un récipient plus grand pour les fuites ( cf Jérome )
Test du capteur de turbidité : valeur de la tension pour la turbidité est de 4,3V (cf code):  test dans une bouteille d'eau transparente, de l'eau d'abord limpide ( U=4,6V) puis ajout de jus de clémentine pour augmenter la turbidité petit à petit. On a fixé la valeur de turbidité maximale avant la régulation du système. Début de test des pompes.
27/01/2023
Test des pompes : Matériel limité pour les pompes :
-pompe à air 12V: Contrôlée par un relai et alimentée 12V : la pompe permet d'ajouter de l'air dans l'aquarium, test de son fonctionnement et de son contrôle

-pompe à eau immmergée, 3V : la pompe est placée dans un réservoir d'eau qui est une source d'eau pure
- pompe à eau,12V permettant l'évacuation de l'eau par le compartiment de pompage :

Finalisation 2ème planche en bois pour  support, collage et joins, collage filtre à caféRégulation de pH

La régulation du pH
Objectif du projet :
Le projet consiste à réguler le pH d’une certaine solution (acide ou basique) en utilisant un programme Arduino. L’idée vient du problème de neutralisation des rejets liquides industriels qui consiste une étape primordiale dans le traitement des déchets.

Le matériel utilisé :
- 4 bouteilles en plastique (2 réservoirs pour l’acide et la base, un réacteur, et un tank).
- 3 électrovannes associées à des relais.
- Une sonde de pH
- Une Tige d’agitation associé à un moteur
- Un afficheur
- Un indicateur de niveau
- Un Arduino avec une plaque d’essai
- Des files et des tuyaux en plastique

- Un support en bois

Les appareils utilisés :

- Découpeuse Laser

- Perceuse à colonne
- Scie électrique
- Imprimante 3D
- Des outils manuels ( pistolet à colle, perceuse, viceuse à main,…)
Les étapes de construction :

Étape 1 : Construction du support

Nous avons utilisé 4 plaques ( 6030 cm^2) pour avoir un support 9060.
Étape 2 : Mise en place des réservoirs
Nous avons fixé d’abord les 2 réservoirs des solutions acide et base. Ensuite, nous avons fixé le réacteur et le tank. Enfin, nous avons fait des trous pour faire passer les tuyaux.
Étape 3 : Mise en place des électrovannes

Nous avons placé les électrovannes à la sortie des deux réservoirs ainsi que le réacteur.
Nous avons associé à ces dernières des relais.
Étape 4 : Impression de la tige
Nous avons fait le design de la tige en utilisant le logiciel Tinkercad, et ensuite nous avons utilisé l'imprimante 3D. Enfin, nous avons relié la tige au moteur.

Régulation et mesure de la couleur par spectrophotométrie

Régulation et mesure de la couleur par spectrophotométrie en utilisant Arduino
Le concept de ce projet est de pouvoir produire un ensemble de couleurs spécifiques par le mélange des trois couleurs primaires (Rouge, Jaune et Bleu) utilisées pour produire ces dernières, cela sera possible par l'utilisation d'un spectrophotomètre qui mesure la couleur de l'échantillon de départ que nous avons (transparent par exemple) ce qui permet au système de savoir quelle quantité des couleurs primaires doit être administrée pour notre résultat final, le spectromètre effectuera ensuite une seconde mesure pour évaluer la qualité de la couleur et si c'est bien le résultat escompté, avec une petite marge d'erreur qui, si elle est dépassée, l'échantillon est administré en quantités appropriées pour atteindre la marge d'erreur acceptée.
Le choix des couleurs utilisés pour le mélange est plutôt simple, le RYB (rouge-jaune-bleu, Red-Yellow-Blue en anglais) est un ensemble historique de couleurs utilisé dans le mélange soustractif de couleurs, et est un ensemble de couleurs primaires couramment utilisé. Elle est principalement utilisée dans l'enseignement de l'art et du design, notamment en peinture.
Les RYB constituent donc les critères de couleur primaire, en concevant la roue chromatique standard de l'artiste. Le secondaires (violet-orange- vert) constituent une autre triade. Les couleurs de la triade (violet-orange- vert) parfois appelée (violet-orange- vert) constitue une autre triade. Les triades sont formées par trois couleurs équidistantes sur une roue de couleur particulière.
Pour créer une large gamme de nouvelles couleurs, les couleurs primaires peuvent être mélangées en utilisant différentes quantités de couleurs proportionnelles les unes aux autres. Mélanger des peintures, des pigments ou des colorants en utilisant des formules de mélange de couleurs proportionnelles garantit qu'une couleur spécifique peut être reproduite, ce qui permet à un artiste d'assurer la cohérence et la prévisibilité du mélange des couleurs.
Le mélange proportionnel des couleurs peut impliquer des rapports simples, comme utiliser deux fois plus de rouge que de jaune, ou des formules complexes, comme mélanger une partie de rouge, deux parties de bleu et trois parties de jaune. Chaque combinaison produira un résultat nouveau et intéressant. L'image de mélange de couleurs jointe ci-dessous présente quelques formules de mélange proportionnel de couleurs.

Pour appliquer cette logique à notre idée de projet, nous utiliserons bien sûr l'Arduino pour le stockage interne d'instructions pour la mise en œuvre de fonctions telles que la logique, le séquençage, la synchronisation, le comptage et l'arithmétique pour contrôler, par le biais de modules d'entrée/sortie numériques ou analogiques, différents types de composants qui constituent notre système.  L'image jointe ci-dessous montre un schéma fonctionnel de ce dernier.

 Le mélange dans le récipient sera soit géré par arduino également, soit nous pourrions utiliser un mélangeur magnétique manuellement.
Le premier modèle :

Spectromètre MIKROE-4165
Led blanche
Breadboard

 La première option est assez simple, une source de lumière normale avec un capteur spectromètre qui, comme son nom l'indique, détecte les différents spectres de la lumière avec un prix élevé à payer pour cette commodité.
Partie Régulation :

Électrovannes LEX-VALVE2
Relais

Électrovanne

Relais

La partie Régulation est assez simple en ce qui concerne le matériel, les électrovannes étant utilisées comme moyen d'administrer les pigments de couleur avec précision pour obtenir les résultats souhaités.
Conception du support du projet 
Matériel utilisé :

Trois goblets en plastique
Tuyaux de 8 mm de diamètre.
Planches en bois faible épaisseur (5-6 mm d’eppaisseur) pour le decoupage laser.
16 visses M5
16 écrous M5
4 équerres

Appareils utilisés : 

Découpeuse Laser
Perceuse à colonne
Imprimante 3D

Logiciels utilisés :

Blender (Pour la conception 3D).
Ink Scape (Puisque la découpeuse laser à besoin d'un fichier au format svg).
IdeaMaker (Pour le découpage du modèle 3D).

Des supports pour le spectrophotomètre et d'autres composants étaient nécessaires, le composant principal étant une plateforme utilisant trois planches dont deux ont les dimensions suivantes (28x20 cm) et ont été utilisées comme support pour où la carte Arduino, la boîte du spectrophotomètre et les récipients à trois couleurs, les deux planches étant collées sur la plus grande planche (58x28 cm). Ce dernier étant conçu à l'aide d'une découpeuse laser.
Le capteur du spectromètre n'ayant besoin que d'une seule source de lumière, il lui fallait un boîtier fermé faisant face à la source de lumière (LED blanche) pour capter la lumière traversant la cuvette remplie de son contenu coloré, voici des photos dudit boîtier modifié à l'aide du logiciel de modélisation gratuit Blender.

Boitier Spectromètre dans Blender

Boitier spectromètre avec composants

Un problème que nous avons rencontré lors de cette phase est le problème de mélange des couleurs administrées, d'autant plus que la cuvette est très petite et ne peut pas entrer dans n'importe quel appretus de mélange, la solution que nous avons trouvé est une sorte de mélangeur en forme d'embout qui regroupe les trois tuyaux qui viennent des électrovannes et les condense en une seule sortie où les trois couleurs mélangées sont versées à l'intérieur de la cuvette, sa conception a également été rendue possible en utilisant le logiciel de modélisation Blender.

Mixeur dans Blender

Mixeur imprimé

Montage :
Pour le montage, on a placé nos gobelets, qui contiendront chacun un de nos 3 colorants, en hauteur sur la plateforme. Nos gobelets sont liés à nos électrovannes via des tuyaux en caoutchouc, et ces mêmes électrovannes sont liées à un mélangeur de la même manière. Nous avons utilisé un embout d’aspirateur pour voiture comme base pour fabriquer notre mélangeur. Le liquide, après être passé dans le mélangeur, entrera dans la cuve afin d’être analysé par le spectrophotomètre. Notre montage est fait de sorte à ce que la gravité suffit à acheminer notre liquide jusqu’à la cuve. Nos électrovannes sont reliées à des relais qui seront fixés à proximité sur la plateforme (juste en dessous).

Les relais serviront à gérer le passage du courant vers l’électrovanne, et donc à gérer son ouverture. Ces relais sont branchés directement sur un breadbord, qui sera posé à la base de notre support. Ce breadbord sera, quant à lui, lié à la carte mère de notre spectrophotomètre. Le breadbord est un outil qui nous servira à lier plusieurs éléments (ici nos relais et notre spectrophotomètre) sans avoir à faire de soudure. Cette carte mère sera elle directement liée au capteur afin de pouvoir traiter les données reçues par le capteur dans le boitier sur le mélange de colorant dans la cuve. L’alimentation en électricité de notre système se fait via la carte mère du spectrophotomètre. Il est nécessaire d’avoir une alimentation assez puissante afin de pouvoir faire fonctionner le circuit. Nous avons au début eu des problèmes à ce niveau car nous avions fait l’erreur d’alimenter le circuit via la batterie d’un ordinateur portable.

Pour résumer, toutes les composants ou le liquide place a été placé en hauteur à différent niveau de sorte à ce que la gravité soit une force motrice suffisante pour le déplacer. Le reste a été placé à la base car plus pratique (sauf les relais qui doivent être à proximité des electrovannes).
Logique du code utilisé : 
Ce code est écrit dans le langage de programmation Arduino et utilise l'environnement de développement intégré (IDE) Arduino. Le code met en œuvre un système de contrôle simple pour contrôler l'intensité des relais électromagnétiques DC rouge, jaune et bleu afin de créer une couleur désirée.
Le code comprend plusieurs bibliothèques, notamment la bibliothèque Wire.h qui fournit une interface TWI/I2C pour la communication entre le microcontrôleur et le capteur AS7341. Les bibliothèques Adafruit_Sensor.h et Adafruit_AS7341.h fournissent le support pour le capteur que nous avons, qui est utilisé pour mesurer les valeurs RGB d'un échantillon de couleur, bien que le nôtre ne soit pas exactement un capteur Adafruit, nous avons pensé que puisqu'ils utilisent le même type de capteur, il peut suivre la même logique et fonctionnalité.
Les broches pour les relais DC électromagnétiques sont définies en utilisant la directive #define du préprocesseur, et la broche de la LED blanche est également définie. Une instance du capteur AS7341 est créée en utilisant Adafruit_AS7341 sensor = Adafruit_AS7341() ;.
Dans la fonction setup(), la communication série est initialisée, les broches du relais et de la LED sont initialisées comme sorties, le capteur AS7341 est initialisé et la couleur désirée est lue sur le clavier. La fonction loop() mesure en continu les valeurs RVB d'une couleur échantillon à l'aide du capteur AS7341 et calcule l'erreur entre la couleur souhaitée et la couleur mesurée. En fonction de l'erreur, la quantité de chaque colorant est mise à jour pour minimiser l'erreur, et les relais électromagnétiques DC sont activés ou désactivés en conséquence. Le code attend 100 millisecondes dans la fonction loop() avant de répéter le processus de mesure et de contrôle.
Look final du projet :

Après le montage correct de tous les composants, le projet était terminé et il ne manquait plus que le code pour l'exécution, le problème résidait dans les bibliothèques ou plutôt dans la mauvaise utilisation de ces dernières lors de l'écriture du code, la logique de ce dernier reposait sur les capacités du capteur à donner les données directement dans un format RGB, une tentative quelque peu délicate qui nécessitait d'autres ajustements.
Une autre logique possible que nous aurions pu poursuivre était d'avoir une sorte de banque de données qui a tous les spectres d'absorption stockés dans lequel il peut être consulté pour reconnaître et produire la couleur, une fonction tout à fait prévisible que ce capteur est capable d'un tel exploit.
Ces deux voies ont nécessité un temps considérable dont nous manquions fortement, le développement de ce code est donc nécessaire au bon fonctionnement de l'appareil.
Les fichiers STL de l'impression ainsi que le fichier Arduino contenant le code sont accessibles en cliquant ici.Machine à Cocktail


UE 803 - Optimisation et Contrôle des Procédés - Master 2 - Ingénierie Chimique
Projet Expérimental Arduino
Dans le cadre de cette UE, nous devons réaliser un projet de régulation par prototypage utilisant principalement un micro contrôleur Arduino et des capteurs / actionneurs.
Après quelques séances de brainstorming et échange d'idées, nous avons décidé d'opter pour la conception d'une machine à cocktail connecté via assistant vocal. Des pompes gèreraient le débit des boissons et un capteur pour la détection d'un gobelet serait ajouté.
Nous avons passé en revu plusieurs projets de système de pompage utilisant Arduino ou un connecteur Nano-IoT et avons donc pu dresser une liste du matériel complet pour mener à bien ce projet.

Projet distributeurs de boissons
Objectif : Réaliser un distributeur de cocktails à partir de 7 boissons (et donc 7 pompes) qui nous permettrait de faire différents mélanges. Le distributeur serait connecté au cloud via un Nano-IoT et contrôlé vocalement par Alexa.
Matériel électronique :

7 pompes
7 relays (ou switch)
fils de connexions

Un nano 33 IoT
Une carte arduino
Une platine
Câble d'alimentation
Câble usb relié à l'arduino
Câble usb relié l'IoT
Un capteur sonar (distance)
4 Boutons poussoirs
4 Résistances

Matériel de construction :

Tuyaux
Planches de bois
Vis
7 Bouteilles vides 1,5L

Premier Brouillon :

____________________________________________________________________________________________________________
Semaine 6 au 13 Décembre :
Une fois tout le matériel reçu, la première étape du projet a été de mettre en place une stratégie pour monter et faire fonctionner les pompes :

Mettre en place le schéma de branchement des pompes
Faire un état des lieux des fils nécessaires (bruts, embout femelle, embout male).
Dénudé la quantité de fils nécessaire
Trouver la borne + et la borne - des pompes en utilisant un multimètre

Après plusieurs recherches et la consultation de plusieurs sites web et pages github, le branchement suivant reliant la pompe, le relay et l'arduino a été déterminé comme celui qui serait utilisé :

L'utilisation d'un relay est essentiel si nous voulons être capable de faire varier l'intensité de la pompe ou sa durée de fonctionnement. En effet la pompe est par défaut une entité booléenne : allumée ou éteinte.
Soudure des fils à nos 7 pompes :

Branchement des fils de connexions aux 7 relays :

Branchement final des pompes aux relay puis sur la carte Arduino :

Semaine 2 Janvier :
Une fois les pompes câblés correctement et branchées, nous devons commencer à programmer nos commandes de boissons, car sinon les pompes sont activés en continues quand connecté à l’alimentation. Nous recherchons donc des exemples de codes qui montrent comment activer une pompe pour un délais précis et initialiser notre setup en fonction du nombre de pompe utilisées.
Un de nos premiers exemple de code utilisé est celui-ci :
Nous arrivons donc maintenant à activer une pompe et contrôler sa durer d’activation. Le but est d’ensuite ajouter toutes nos pompes et crée des fonctions qui gèrent l’activation de 2 pompes en même temps gérer par une seule fonction « boisson »pour réaliser les mélanges de nos cocktails.
Nous cherchons également en parallèle comment se branche et fonctionne notre capteur sonar de distance. En effet après plusieurs recherches nous nous sommes rendu compte que notre capteur ne possède pas les branchements décrit habituellement dans la littérature et autres projet libre d’accès.

En effet, dans nos nombreuses recherches de fonctionnement du capteur nous retrouvions tout le temps le capteur ci-dessus. Qui possède quatre branchements : Vcc qui correspond au voltage 3,3 ou 5V, GND qui correspond comme l'indique son nom à la terre (ou ground). Et finalement les branchements Trig et Echo où Trig correspond au transmetteur soit la partie de gauche qui va émettre des impulsions qui seront arrêtées et renvoyé par l'objet qui fait face au capteur. Ces impulsions renvoyées sont captées par le récepteur qui correspond à l'Echo (partie de droite).
Cependant, nous ne sommes pas exactement dans ce cas-là.

Ici, les sorties Trig et Echo sont remplacés par la sortie SIG qui fait office de branchement pour le transmetteur et le récepteur et sera branché sur le pin digital dans notre cas le pin 10. La sortie NC (ou "not connected") est comme l'indique son nom une sortie qui n'a pas besoin d'être relié à quoi que ce soit. GND et VCC sont des branchements qui se font à l'identique de ce qui a été expliqué précédemment. Le branchement de notre capteur est donc simplifié mais il a fallu faire un travail d’identification pour assurer une connexion.
Branchement capteur :

Semaine 9 Janvier :
Nous avons pu réaliser les branchements du capteur et les avons reliés correctement à l’Arduino. Nous devons désormais adapter notre code afin de spécifier les fonctions liées au fonctionnement du capteur mais aussi ajouter une nouvelle condition sur l’activation des pompes : les pompes ne peuvent s’activer que si le capteur détecte une présence proche à moins ou égale à 2cm de distance du récepteur du capteur.
Nous nous penchons également sur le Nano-IoT fait pour relier notre système au service cloud de Arduino afin de créer des boutons digitaux (web ou application mobile) contrôlable manuellement ou par assistanats vocaux grâce à la configuration de ces boutons digitaux en skills Alexa.
Pour ce faire nous commençons à souder les branches en or fournis avec note Nano-IoT 33 pour pouvoir faire des branchement. Une fois fait, il est connecté sur une platine et branché par un câble USB à l’ordinateur pour la création des boutons et du code associé.
Nano IoT :

Après soudures :

Nous cherchons dans la documentation Arduino le nom des connexions disponible sur notre connecteur bluetooth car ils ne sont pas inscrit sur notre appareil :

Une fois les soudures réalisées et la documentation en notre possession, nous pouvons tenter de recréer les connexions réalisées précédemment sur l’Arduino avec une pompe sur le Nano-IoT afin de commencer à comprendre le fonctionnement du service cloud. Nous souhaitons avoir 7 boissons, donc 7 boutons, qui vont activer des jeux de pompes différentes, nous créerons donc nos boutons auxquels nous relions des variables booléenne (TRUE or FASLE) qui gèrent l’état des boutons « Appuyer ou Étein » et devons coder dans la partie du code auto généré par Arduino Cloud pour contrôler l’action réaliser après activation des boutons.
Après plusieurs recherches sur le fonctionnement d’Arduino Cloud et du IoT nous associons notre appareil à leur application, et nous nous connectons à un réseau wifi privé et sécurisé. Nous pouvons alors créer  nos « things » qui sont nos variables qui vont gérer l’allumage des pompes et donc la création des boissons. Nous commençons d’abord à travailler avec une seule pompe et sans capteur pour bien comprendre comment marche cet appareil.

Nous avons alors crée nos 4 variables pour 4 boissons, et n’allons travailler que sur la boisson 1 avec une seule pompe pour l’instant. Nous pouvons alors passer à la suite et créer nos boutons virtuels, on associe alors les variables créees précédemment à chaque boutons. Nos variables sont définies comme booléenne, read & write et sa valeur est actualisée à chaque changement d’état du bouton.

Arduino Cloud nous auto crée alors une partie de code où nous avons plus qu’a ajouter nos fonctions de contrôle des pompes. Dans la photo ci-dessous le code n’est pas correcte, mais nous avons utilisé le code montré précédemment, utilisé pour la carte Arduino. Nous avons vérifié la syntaxe et télévisé le code sans aucun problème. Les boutons devraient donc marcher.

Par la suite nous créons donc les skills Alexa nécessaires pour le contrôle vocal de l’activation des boutons crées précédemment, codé et associé à l’IoT.

Le code marche sur l’arduino, les boutons sont reliés au variables, le code transféré à l’IoT à la bonne syntaxe compatible Cloud Agent et le téléversement se fait « succesfully » et sans erreur, malheureusement impossible de connecter le IoT au cloud. Il reste « Hors ligne » en permanence. Normalement après le téléversement, le IoT est sensé se connecter immédiatement au cloud et être « Online », nous avons vu une connexion de 1 seconde puis déconnexion immédiate. Après plusieurs recherche il se peut que le réseau cloud de Arduino soit en maintenance ou inaccessible. Nous avons essayé plusieurs réseau différents par la suite, et malgré le téléversement réussi et une connexion privé, notre IoT ne se connecte pas au Cloud, impossible donc d’activer les boutons sur le site web et encore moins à distance avec Alexa.
Après de nombreuses tentatives infructueuses cette semaine, et le fait que ni l’université ni le fablab ne possèdent de réseau wifi privé auquel nous pourrions nous connecter pour présenter la machine lors du rendu final, nous décidons d’abandonner l’idée de contrôle par assistant vocal ou de boutons virtuels. Il faut alors trouver une autre solution.
Semaine 16 Janvier :
Nous arrivons plus ou moins à faire marcher le capteur et une pompe, mais pour l’instant nous n’arrivons pas à spécifier la condition && du fonctionnement des 2 pompes en même temps que le capteur. Nous travaillons donc a améliorer le code et tenté de trouver une version qui fonctionne.
Cette semaine nous commençons également à avancer sur la structure : nous avons fait un état des lieux et avons défini que nous avions besoin d’un bac pour récuperer le liquide sous le verre, d’une partie haute qui dispense le liquide et qu’un « réservoir » qui contiendrais nos bouteilles et doit etre accessible pour les changer ou faire une maintenance des équipements. Le capteur, les pompes et le arduino avec la platine ce trouveraient à l’interieur de la machine, au dessus des bouteilles d’ou sont pompé les liquides.
Un premier croquis est suggéré :

Le bac d’écoulement du liquide au cas où des goutes couleraient à coté lors de la distribution de boisson est assez indépendant de la machine et peut être rajouté seule, nous commençons donc a réfléchir à un design de conception pour commencer par cette pièce, étant donné que le code n’est pas définitif nous ne préférons pas avancer de suite sur la structure définitive.
Le bac d’écoulement était initialement prévu en bois tout comme le reste de a structure de la machine mais ce matériaux n’est pas hydrophobe et se gorgera d’eau s’il est en contact avec. A la fin de cette séance fablab nous décidons donc de partir sur du plastique PMMA de 3mm d’épaisseur et de couleur noir (pas transparent car nous verrions le liquide à travers, ce qui n’est pas très esthétique dans ce cas). Nous commençons donc par réaliser une fichier vectoriel 2D grâce au logiciel Inkscape afin de dessiner les bordures de nos pièces en vue d’une découpe laser. Dans un premier temps nous optons pour un porte gobelet de 10x10cm et avons réaliser le fichier suivant pour la découpeuse laser :

Semaine 23 Janvier :
Coté code, nous arrivons finalement à faire fonctionner une pompe d'après la condition de distance sur le capteur que nous avions spécifié à moins de 3 cm. Nous pouvons alors tenter de reproduire les branchements pour toutes nos pompes et commencer à structurer notre code avec les pompes correspondant aux boissons souhaitées.

Faisant face à des problèmes pour travailler avec le Nano-Iot comme nous le souhaitions, nous avons cherché en parallèle une alternative pour proposer nos différentes boissons. Et pour cela, nous avons décidé de travailler avec des boutons poussoirs. C'est aussi à ce moment qu'il nous a semblé judicieux de nous limiter dans le nombre de pompes en passant de  7 à 4 pompes ce qui nous permettait aussi d'avoir un plus petit montage à réaliser pour notre design.

Remarque : Un fil GND (Noir) et un fil 5V (Blanc) sont reliés de l'arduino vers la platine respectivement sur la bande moins et la bande plus. Tous les fils devant être reliés au GND seront donc sur la ligne des moins et ceux devant être reliés au 5V seront sur la ligne des plus.
Nous arrivons à réaliser un premier montage pour activer une pompe à l'aide d'un bouton, mais nous éprouvons quelques problèmes pour le code pour apposer la condition && entre le capteur et le bouton. En effet, nous souhaitons que la pompe s'active si et uniquement si l'obstacle se trouve à moins de 3 cm du capteur et si le bouton a été activé.
En essayant une condition if ((bouton == 0) && (cm<3)), nous remarquons que le bouton n'est pas pris en compte dans l'activation de la pompe. Pour finalement faire fonctionner nos deux conditions, il nous a fallu déclarer nos conditions comme des variables "boolean" dites aussi "tout ou rien". C'est ce qu'il est possible de voir en rouge dans le code correspondant au montage (a).
Cela nous permet d'indiquer à l'arduino que nous avons deux états pour chacune de nos variables : état 0 où le bouton n'a pas été activé et où le capteur ne repère un obstacle à moins de 3 cm et l'état 1 où le bouton est activé et le capteur identifie bien un obstacle à moins de 3 cm.
const int pingPin = 7;
const int pumpPin2 = 2; // // le relais est connecté à la broche  de la carte Adruino
const int bouton1 = 3;

boolean boutonappuye1;
boolean proche;

void setup() {

 // initialize serial communication:

 Serial.begin(9600);

 // The PING))) is triggered by a HIGH pulse of 2 or more microseconds.

 // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:

 pinMode(pumpPin2, OUTPUT);

 pinMode(bouton1,INPUT);

}

void loop() {

 // establish variables for duration of the ping, and the distance result

 // in inches and centimeters:

 long duration, inches, cm;

 // The same pin is used to read the signal from the PING))): a HIGH pulse

 // whose duration is the time (in microseconds) from the sending of the ping

 // to the reception of its echo off of an object.

 pinMode(pingPin, OUTPUT);

 digitalWrite(pingPin, LOW);

 delayMicroseconds(2);

 digitalWrite(pingPin, HIGH);

 delayMicroseconds(5);

 digitalWrite(pingPin, LOW);

 pinMode(pingPin, INPUT);

 duration = pulseIn(pingPin, HIGH);

 // convert the time into a distance

 inches = microsecondsToInches(duration);

 cm = microsecondsToCentimeters(duration);

 Serial.print(cm);

 Serial.print("cm");

 Serial.println();

 boutonappuye1 = digitalRead(bouton1);

 Serial.println(boutonappuye1);

 proche = (cm<3);

 if (boutonappuye1 && proche)

 {

 digitalWrite(pumpPin2, LOW);// la pompe à eau remplit la bouteille

 }

 else {

 digitalWrite(pumpPin2, HIGH); // la pompe à eau s'arrête

 }

}

long microsecondsToInches(long microseconds) {

 // According to Parallax's datasheet for the PING))), there are 73.746

 // microseconds per inch (i.e. sound travels at 1130 feet per second).

 // This gives the distance travelled by the ping, outbound and return,

 // so we divide by 2 to get the distance of the obstacle.

 // See: https://www.parallax.com/package/ping-ultrasonic-distance-sensor-downloads/

 return microseconds / 74 / 2;
}

long microsecondsToCentimeters(long microseconds) {

 // The speed of sound is 340 m/s or 29 microseconds per centimeter.

 return microseconds / 29 / 2;
}
Remarque : Ce code fonctionne de telle manière qu'il indique que lorsque le capteur détecte un obstacle à moins de 3 cm et le bouton est appuyé alors la pompe est allumé. Cependant d'après le code c'est l'inverse qui devrait se passer puisqu'il est indiqué que la pompe est en "LOW". Nous expliquons cela par le fait que des branchements sont inversés et inversent donc la consigne.
A partir de ce premier code, nous pouvons donc activer les pompes lorsque la condition du capteur et du bouton est respecté et si l'on s'éloigne assez du capteur ou si nous arrêtons d'appuyé sur le bouton alors la pompe s'arrête.

Nous souhaitions qu'une fois que le bouton n'est pas besoin d'être pressé en continue pour obtenir notre boisson. nous avons rajouter des "delay" pour activer les pompes un temps donné. Dans ce cas, le capteur et le bouton restent bloqués en position 1 tant que le delay n'est pas arrivé à termes, cela signifie que nous ne pouvons pas arrêter la pompe lorsque  les deux conditions sont réunis une fois.

Coté design nous choisissons une version un peu plus définitive du modèle final de la machine et faisons l’inventaire des planches et tailles de planches nécessaires :

Nous prévoyons donc d’utiliser une planche intermédiaire en hauteur afin de fixé les pompes à coté de l’arduino et de dédier un espace spécifique pour les bouteilles et les tubes. Cependant, nous voyons d’or et déjà que nous n’allons pas avoir assez de tube en plastique fournis. Effectivement nous n’avons qu’un seul mètre de tube pour un total de 4 pompes au final, dont 1 tube dois descendre tout au fond de la bouteille, et l’autre ressortir au point d’écoulement du liquide sur la machine. Nous faisons donc le choix de sacrifier de la longueur de file dans le fond de certaines bouteilles.

Semaine 30 Janvier :
Plusieurs étapes du projet sont réalisées cette semaine, nous travaillons à la fois sur la finalisation de notre code et de notre montage pour quatre pompes et quatre boutons, mais aussi sur la construction de la structure et sur le site que nous avons souhaité réaliser afin de présenter nos boissons.

Réalisation du site :
Pour finaliser le projet il nous a fallu trouver la meilleure interface afin de rendre le distributeur ergonomique et facile d’utilisation. Nous avons donc décidé de commencer une maquette. Comme il était complexe de faire un design directement sur la machine nous avons pensé faire un menu virtuel.  Nous sommes tout d’abord partis sur une carte virtuelle avec le menu lié à un QR Code sur la machine.

Après réflexions nous avons décidé de voir encore plus loin en créant un site permettant d’avoir accès aux menus.  Le site s’appelle Flamme & Co, un nom qui nous embarque dans une ambiance chaleureuse avec « Flamme » et rafraichissante avec « Co » (pour coktail), et qui nous fait voyager : Flamenco (Flamme & Co). Le site est composé de l’accueil où l’on peut trouver les différentes informations clés sur la marque.

D’autre part dans l’onglet « Commandes en ligne » on peut retrouver et choisir les différentes boissons proposées.

Pour rendre accessible le site, nous avons souhaité installer un QR code sur notre machine afin d'y avoir directement accès et pouvoir découvrir le détails des boissons proposées.

Code et montage :
Le montage et le code ayant été réalisé pour une pompe liée à un bouton et au capteur, la suite était donc d'appliquer tout cela à quatre pompes et quatre boutons afin d'avoir deux cocktails et deux boissons à proposer.

En suivant le même montage que celui pour une pompe et un bouton, nous avons donc réussi à le reproduire avec nos trois pompes et boutons supplémentaires.

Le code suivant nous permet d'activer nos quatre pompes avec quatre boutons.

const int pingPin = 10;

const int pumpPin2 = 2; // // le relais est connecté à la broche  de la carte Adruino
const int pumpPin3 = 3; // // le relais est connecté à la broche  de la carte Adruino
const int pumpPin4 = 4; // // le relais est connecté à la broche  de la carte Adruino
const int pumpPin5 = 5; // // le relais est connecté à la broche  de la carte Adruino

const int bouton1 = 6;
const int bouton2 = 7;
const int bouton3 = 8;
const int bouton4 = 9;

boolean boutonappuye1;
boolean boutonappuye2;
boolean boutonappuye3;
boolean boutonappuye4;

boolean proche;

void setup() {

 // initialize serial communication:

 Serial.begin(9600);

 // The PING))) is triggered by a HIGH pulse of 2 or more microseconds.

 // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:

 pinMode(pumpPin2, OUTPUT);

 pinMode(pumpPin3, OUTPUT);

 pinMode(pumpPin4, OUTPUT);

 pinMode(pumpPin5, OUTPUT);
;

 pinMode(bouton1,INPUT);

 pinMode(bouton2,INPUT);

 pinMode(bouton3,INPUT);

 pinMode(bouton4,INPUT);

}

void loop() {

 // establish variables for duration of the ping, and the distance result

 // in inches and centimeters:

 long duration, inches, cm;

 // The same pin is used to read the signal from the PING))): a HIGH pulse

 // whose duration is the time (in microseconds) from the sending of the ping

 // to the reception of its echo off of an object.

 pinMode(pingPin, OUTPUT);

 digitalWrite(pingPin, LOW);

 delayMicroseconds(2);

 digitalWrite(pingPin, HIGH);

 delayMicroseconds(5);

 digitalWrite(pingPin, LOW);

 pinMode(pingPin, INPUT);

 duration = pulseIn(pingPin, HIGH);

 // convert the time into a distance

 inches = microsecondsToInches(duration);

 cm = microsecondsToCentimeters(duration);

 Serial.print(cm);

 Serial.print("cm");

 Serial.println();

 boutonappuye1 = digitalRead(bouton1);

 Serial.println(boutonappuye1);

 boutonappuye2 = digitalRead(bouton2);

 Serial.println(boutonappuye2);

 boutonappuye3 = digitalRead(bouton3);

 Serial.println(boutonappuye3);

 boutonappuye4 = digitalRead(bouton4);

 Serial.println(boutonappuye4);

 proche = (cm<5);

 if (boutonappuye1 && proche)

 {

 digitalWrite(pumpPin2, LOW);// la pompe à eau remplit la bouteille

 digitalWrite(pumpPin3, LOW);// la pompe à eau remplit la bouteille

 delay(5000);

 digitalWrite(pumpPin2, HIGH); // la pompe à eau s'arrête

 digitalWrite(pumpPin3, HIGH);// la pompe à eau s'arrête

}

 else {

 digitalWrite(pumpPin2, HIGH); // la pompe à eau s'arrête

 digitalWrite(pumpPin3, HIGH);// la pompe à eau s'arrête

 }

 if (boutonappuye2 && proche)

 {

 digitalWrite(pumpPin5, LOW);// la pompe à eau remplit la bouteille

 delay(5000);

 }

 else {

 digitalWrite(pumpPin5, HIGH);// la pompe à eau s'arrête

 }

 if (boutonappuye3 && proche){

 digitalWrite(pumpPin4, LOW);// la pompe à eau remplit la bouteille

 delay(5000);

 digitalWrite(pumpPin4, HIGH);// la pompe à eau s'arrête

 }

 else {

 digitalWrite(pumpPin4, HIGH); // la pompe à eau s'arrête
}

 if (boutonappuye4 && proche) {

 digitalWrite(pumpPin2, LOW);// la pompe à eau remplit la bouteille

 delay(5000);

 digitalWrite(pumpPin2, HIGH);// la pompe à eau s'arrête

 }

 else {

 digitalWrite(pumpPin2, HIGH); // la pompe à eau s'arrête

 }
}

long microsecondsToInches(long microseconds) {

 // According to Parallax's datasheet for the PING))), there are 73.746

 // microseconds per inch (i.e. sound travels at 1130 feet per second).

 // This gives the distance travelled by the ping, outbound and return,

 // so we divide by 2 to get the distance of the obstacle.

 // See: https://www.parallax.com/package/ping-ultrasonic-distance-sensor-downloads/

 return microseconds / 74 / 2;
}

long microsecondsToCentimeters(long microseconds) {

 // The speed of sound is 340 m/s or 29 microseconds per centimeter.

 return microseconds / 29 / 2;
}
Nous nous sommes rendus compte lorsque nous avons voulu faire fonctionner notre montage avec les quatre pompes que la pompe 4 ne fonctionnait pas. Nous l'avons testée toute seule et elle ne fonctionnait toujours pas. En essayant de la changer avec une des trois autres pompes qui nous restait nous avions toujours le même problème et sommes resté assez longtemps bloqué dessus.

Au final en essayant de refaire deux montages séparés avec deux pompes sur des platines différentes puis de les assembler ensemble sur une seule platine et un seule arduino, nous avons fini par avoir un montage fonctionnel associé à un code fonctionnel.
En parallèle, nous travaillons sur le montage de la structure :
Prise de mesures réelles et découpes des 1er planches. Nous cherchons le materiel le plus adapté pour crée le cadre de notre machine. Nous avons choisi du bois car léger et facile d’accès et facilement découpable et donc assemblable. Nous avons opté pour du bois de 7mm afin d’assurer l’intégrité de la machine.
Plusieurs options : rails, clous, colle, découpage pour entrelacement du bois, vis…

Peu de vis avaient une taille adapté à notre taille de bois, en effet soit elles étaient au bon diamètre mais trop longues, soit à la bonne longueur mais beaucoup trop large. (suite...)
Nous travaillons donc avec la découpeuse laser pour les découpes concernant le bac de récupération, les planches de la structure (pour les façonner à la bonne taille et faire les trous nécessaires pour faire passer nos éléments comme les tuyaux reliés aux pompes par exemple). La machine à gravure est aussi utilisée pour notre le QR code amenant à notre site, mais aussi pour la plaquette comportant le nom de notre groupe et nos noms.
Nous nous sommes énormément aidé de la découpeuse laser pour couper nos planches. Nous avons utilisé 7 planches principales ;
-3 planches de 22,5 x 50 cm, une en arrière qui peut s’ouvrir, les deux autres sur les côtés.
-1 planche de 22,5 x 45,4 cm, pour placer notre équipement, pompes, arduino, breadboard.

-2 planches de 22,5 x 30 cm, une pour placer nos bouteilles et l’autre pour placer notre capteur sonore.
-1 planche de 22,5 x 13,1 cm, pour placer la carte électronique.
Nous avons également découpé des trous pour faire passer nos tuyaux en travers, 4 trous ont été fait et chacun d’eux a un diamètre de 0,9 cm, quant à nos pompes nous avons décidé de les coller directement sur la planche où nous avons placer la breadboard et l’arduino.

Un cinquième trou de 1,8 cm de diamètre a été conçu pour que nous puissions réunir tous nos tuyaux

Semaine du 6 Février :
Pour réaliser notre machine, nous avons décidé de partir sur 4 boissons différentes : eau, jus de pomme, Coca et Whisky. Nous avons donc utilisé 4 pompes différentes et 4 boutons poussoirs. Notre but était d’avoir au moins un mélange parmi les différentes boissons, nous avons donc opté pour un mélange whisky coca qui est contrôlé par un seul bouton quant aux trois autres boutons eux vont permettre de donner les boissons sans mélange ; eau, jus de pomme, Coca.
Concernant le code, comme nous avions besoin d'un capteur déclenchant une action nous avions donc fait en sorte de mettre en place deux conditions pour que notre machine fonctionne. Appuyer sur le bouton est obligatoire pour utiliser la machine mais aussi cette condition doit être accompagnée par une autre condition qui est d'être à une distance bien spécifique du capteur sonar pour que le gobelet se remplisse. Si les deux conditions ne sont pas respectées alors rien ne s’écoule des tuyaux.
Pour une question de simplicité d’accès et d’esthétique nous avons soudé les boutons poussoirs sur une carte électronique (circuit imprimé).

Il nous faut ensuite y souder des fils de connexions qui pourront ensuite être reliés à la platine. Attention à être attentif aux placements des fils en comparant l'endroit et l'envers. En effet, en suivant le montage initial, nous savons que le fil GND est en haut à droite, le fil 5V est en haut à gauche et le fil pour le pin digital est à en bas à droite. Donc pour souder correctement en gardant ces emplacements, ils nous faut souder notre fil noir (GND) en haut à gauche, le fil blanc (5V) en haut à droite et le fil bleu (digital) en bas à gauche. Comme montré dans la photo ci-dessous :

Nous pouvons ensuite relier les fils à la platine.

Il est donc possible de voir l'agencement de nos pompes et de leurs tuyaux dans notre machine. Les bouteilles se trouvant en dessous de la planche. (photo ?).

Jeudi 9 Février :
Le jour de la présentation, les dernières retouches sont faites ; le montage du bac d’écoulement, les dernières planches sont mises en place.
Nous effectuons nos gravures pour le QR code et celle de présentation du projet.

Nous avons rencontré un problème avant la présentation, la breadboard a cessé de fonctionner, nous étions obligés de refaire les branchements, deux des pompes utilisées n’étaient pas assez puissante, le tuyau utilisé avait une longueur de 1 m ce qui n’était pas assez long (par exemple nous n’avons pas pu faire rentrer complètement nos tuyaux dans les bouteilles ; conséquence très peu de liquide sortait du tuyau.)
Nous devons aussi adapter le code au vu de la puissance des pompes. Nous rappelons que les pompes 2 et 3 ne sont pas assez puissante pour pomper n'importe quel liquide. Et nous devons nous rattraper uniquement en utilisant les pompes 4 et 5 correspondant respectivement au whisky et au jus de pomme.

const int pingPin = 10;

const int pumpPin2 = 2; // // le relais est connecté à la broche de la carte Adruino
const int pumpPin3 = 3; // // le relais est connecté à la broche de la carte Adruino
const int pumpPin4 = 4; // // le relais est connecté à la broche de la carte Adruino
const int pumpPin5 = 5; // // le relais est connecté à la broche de la carte Adruino

const int bouton1 = 6;
const int bouton2 = 7;
const int bouton3 = 8;
const int bouton4 = 9;

boolean boutonappuye1;
boolean boutonappuye2;
boolean boutonappuye3;
boolean boutonappuye4;

boolean proche;

void setup() {
 // initialize serial communication:

 Serial.begin(9600);

 // The PING))) is triggered by a HIGH pulse of 2 or more microseconds.
 // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
 pinMode(pumpPin2, OUTPUT);
 pinMode(pumpPin3, OUTPUT);
 pinMode(pumpPin4, OUTPUT);
 pinMode(pumpPin5, OUTPUT);
;
 pinMode(bouton1,INPUT);
 pinMode(bouton2,INPUT);
 pinMode(bouton3,INPUT);
 pinMode(bouton4,INPUT);

}

void loop() {
 // establish variables for duration of the ping, and the distance result
 // in inches and centimeters:
 long duration, inches, cm;

 // The same pin is used to read the signal from the PING))): a HIGH pulse
 // whose duration is the time (in microseconds) from the sending of the ping
 // to the reception of its echo off of an object.
 pinMode(pingPin, OUTPUT);
 digitalWrite(pingPin, LOW);
 delayMicroseconds(2);
 digitalWrite(pingPin, HIGH);
 delayMicroseconds(5);
 digitalWrite(pingPin, LOW);
 pinMode(pingPin, INPUT);
 duration = pulseIn(pingPin, HIGH);
 

 // convert the time into a distance
 inches = microsecondsToInches(duration);
 cm = microsecondsToCentimeters(duration);

 Serial.print(cm);
 Serial.print("cm");
 Serial.println();

 boutonappuye1 = digitalRead(bouton1);
 Serial.println(boutonappuye1);
 boutonappuye2 = digitalRead(bouton2);
 Serial.println(boutonappuye2);
 boutonappuye3 = digitalRead(bouton3);
 Serial.println(boutonappuye3);
 boutonappuye4 = digitalRead(bouton4);
 Serial.println(boutonappuye4);
 
 proche = (cm<3);
 digitalWrite(pumpPin2, HIGH);
 digitalWrite(pumpPin3, HIGH);
 digitalWrite(pumpPin4, HIGH);
 digitalWrite(pumpPin5, HIGH);
 
 if (boutonappuye1 && proche)
 {
 
 digitalWrite(pumpPin4, LOW);// la pompe à whisky remplit le verre
 delay(10000);
 digitalWrite(pumpPin4, HIGH);// la pompe à whisky s'arrête
 digitalWrite(pumpPin2, LOW);// la pompe à coca remplit le verre
 delay(40000);
 digitalWrite(pumpPin2, HIGH);// la pompe à coca s'arrête
 } 
 else {
 
 digitalWrite(pumpPin4, HIGH); // la pompe à eau s'arrête
 digitalWrite(pumpPin2, HIGH);// la pompe à eau s'arrête
 
 } 

 if (boutonappuye2 && proche)
 {
 
 digitalWrite(pumpPin5, LOW);// la pompe à jus de pomme est amené au verre
 delay(60000);
 digitalWrite(pumpPin5, HIGH);
 } 
 
 else {
 digitalWrite(pumpPin5, HIGH);// la pompe s'arrête
 
 } 
 if (boutonappuye3 && proche){
 
 digitalWrite(pumpPin3, LOW);// la pompe à eau remplit le verre
 delay(10000);
 digitalWrite(pumpPin3, HIGH);// la pompe à eau s'arrête
 } 
 
 else {
 
 digitalWrite(pumpPin3, HIGH); // la pompe à eau s'arrête
}
 if (boutonappuye4 && proche) {
 
 digitalWrite(pumpPin2, LOW);// la pompe à coca remplit le verre
 delay(5000);
 digitalWrite(pumpPin2, HIGH);// la pompe à coca s'arrête
 } 
 
 else {
 
 digitalWrite(pumpPin2, HIGH); // la pompe à coca s'arrête
 }
}

long microsecondsToInches(long microseconds) {
 // According to Parallax's datasheet for the PING))), there are 73.746
 // microseconds per inch (i.e. sound travels at 1130 feet per second).
 // This gives the distance travelled by the ping, outbound and return,
 // so we divide by 2 to get the distance of the obstacle.
 // See: https://www.parallax.com/package/ping-ultrasonic-distance-sensor-downloads/
 return microseconds / 74 / 2;
}

long microsecondsToCentimeters(long microseconds) {
 // The speed of sound is 340 m/s or 29 microseconds per centimeter.
 return microseconds / 29 / 2;
}

Il nous faut donc 1 minute d'activité de notre pompe 5 pour pouvoir remplir à moitié notre verre de 33 cl, ce qui corroborent notre hypothèse que les pompes ne sont pas assez performantes.

Mardi 14 février :
Nous sommes revenus ce mardi pour apporter quelques finitions au projet.
Il fallait notamment refermer la structure avec la planche du haut pour pouvoir cacher les branchements.  Elle avait été découpé un peu plus grande que prévue, nous avons donc du la repasser à la découpeuse laser pour enlever 1 mm dans la largeur et 5 mm dans la longueur.

Au vu des problèmes de pompes, nous avions comme objectif de changer les pompes 2 et 3 qui ne fonctionnaient pas assez contre d'autres qui seraient éventuellement assez puissantes. En testant les 3 pompes supplémentaires qui n'étaient pas initialement utilisées, aucunes d'entre elles ne permettaient de pomper du liquide.

La décision a été prise de se limiter à deux pompes fonctionnelles et donc deux boutons. Le montage final comporte deux pompes, la pompe 4 relié au coca et la 5 au jus de pomme. Le coca est servi lorsque nous appuyons sur le bouton 1 et le bouton 2 est pour le jus de pomme.

En testant à nouveau les pompes, nous avons décidé de changer les temps de "delay", car en effet pour un temps de fonctionnement de 25000 ms ou 25 s, nous avons environ 12,5 cl de boisson versé, ce qui nous a semblé adapté pour différents volume de verre.

const int pingPin = 10;

const int pumpPin4 = 4; // // le relais est connecté à la broche de la carte Adruino
const int pumpPin5 = 5; // // le relais est connecté à la broche de la carte Adruino

const int bouton1 = 6;
const int bouton2 = 7;

boolean boutonappuye1;
boolean boutonappuye2;

boolean proche;

void setup() {
 // initialize serial communication:

 Serial.begin(9600);

 // The PING))) is triggered by a HIGH pulse of 2 or more microseconds.
 // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:

 pinMode(pumpPin4, OUTPUT);
 pinMode(pumpPin5, OUTPUT);
;
 pinMode(bouton1,INPUT);
 pinMode(bouton2,INPUT);

}

void loop() {
 // establish variables for duration of the ping, and the distance result
 // in inches and centimeters:
 long duration, inches, cm;

 // The same pin is used to read the signal from the PING))): a HIGH pulse
 // whose duration is the time (in microseconds) from the sending of the ping
 // to the reception of its echo off of an object.
 pinMode(pingPin, OUTPUT);
 digitalWrite(pingPin, LOW);
 delayMicroseconds(2);
 digitalWrite(pingPin, HIGH);
 delayMicroseconds(5);
 digitalWrite(pingPin, LOW);
 pinMode(pingPin, INPUT);
 duration = pulseIn(pingPin, HIGH);
 

 // convert the time into a distance
 inches = microsecondsToInches(duration);
 cm = microsecondsToCentimeters(duration);

 Serial.print(cm);
 Serial.print("cm");
 Serial.println();

 boutonappuye1 = digitalRead(bouton1);
 Serial.println(boutonappuye1);
 boutonappuye2 = digitalRead(bouton2);
 Serial.println(boutonappuye2);
 
 proche = (cm<5);
 
 
 if (boutonappuye1 && proche)
 {
 
 digitalWrite(pumpPin4, LOW);// la pompe à eau remplit la bouteille
 delay(25000);
 digitalWrite(pumpPin4, HIGH);// la pompe s'arrête

 } 
 
 else {
 digitalWrite(pumpPin4, HIGH);// la pompe s'arrête
 
 } 

 if (boutonappuye2 && proche)
 {
 
 digitalWrite(pumpPin5, LOW);// la pompe à coca remplit la bouteille
 delay(25000);
 digitalWrite(pumpPin5, HIGH);// la pompe s'arrête

 } 
 
 else {
 digitalWrite(pumpPin5, HIGH);// la pompe s'arrête
 
 } 
}

long microsecondsToInches(long microseconds) {
 // According to Parallax's datasheet for the PING))), there are 73.746
 // microseconds per inch (i.e. sound travels at 1130 feet per second).
 // This gives the distance travelled by the ping, outbound and return,
 // so we divide by 2 to get the distance of the obstacle.
 // See: https://www.parallax.com/package/ping-ultrasonic-distance-sensor-downloads/
 return microseconds / 74 / 2;
}

long microsecondsToCentimeters(long microseconds) {
 // The speed of sound is 340 m/s or 29 microseconds per centimeter.
 return microseconds / 29 / 2;
}

Régulation du taux d'humidité

UE 803 - Optimisation et Contrôle des Procédés - Master 2 - Ingénierie Chimique
Projet Expérimental Arduino
Objectif du projet :
Réussir à réguler un flux d'air sec et un flux de d'air humidifié à l'aide d'un barboteur pour réguler le taux d'humidité dans l'air à l'aide de 2 pompes et du logiciel Arduino.
Pourquoi avons-nous choisi ce projet ?

La régulation de l'humidité de l'air est un procédé très utilisé en industrie pour réaliser des analyses qualitatives mais aussi dans le but de tester la résistance de certains produits à l'humidité notamment en industrie.

Liste du matériel :
2 x Électrovannes pour l'air
2 x Tuyaux hermétiques pour le montage qui seront découpés en plusieurs morceaux
1 x Barboteur maison

1 x Capteur d’humidité
2 x Pompes
1 x Carte Arduino
2 x bouteilles
1 x paquet de riz

2 x relais

fils électrique pour raccorder les appareils entre eux
- Réalisation d'un schéma prototype du montage (28/10/2022)

On a réalisé un premier schéma du montage afin d'étudier les équipements dont nous aurions besoin pour réaliser notre projet.
- Réalisation du support du projet (12/01/2023)

Sur cette première image on peut voir support qui a été assemblé à partir de bois recycler.
- Réalisation du barboteur (12/01/2023)

                                   

Afin de réaliser notre barboteur nous utilisons une bouteille de soda sur laquelle nous réalisons 2 trous : le 1er en bas de la bouteille qui est la sortie d'air humide et le second en haut de la bouteille au niveau du bouchon pour l'entrée gaz sec. Les trous ont été réalisés à l'aide de la perceuse à colonne qui nous permet d'avoir plus de précision pour la réalisation de nos trous. Pour humidifier l'air il entre par le haut de la bouteille dans un tube qui bullera dans l'eau pour l'humidifier.

- Réalisations des relais pour le contrôle des pompes (12/01/2023)

Des relais ont été ajoutés afin de pouvoir contrôler les pompes individuellement en fonction du signal envoyé par la carte arduino.
- Réalisation du montage Arduino / Code (26/01/2023)

Code que nous avons trouvé et qui a été testé :
*/

#include <DHT.h>
#define brocheDeBranchementDHT 6 // La ligne de communication du DHT22 sera donc branchée sur la pin D6 de l'Arduino
#define typeDeDHT DHT22 // Ici, le type de DHT utilisé est un DHT22 (que vous pouvez changer en DHT11, DHT21, ou autre, le cas échéant)

// Instanciation de la librairie DHT
DHT dht(brocheDeBranchementDHT, typeDeDHT);

// ========================
// Initialisation programme
// ========================
void setup () {
 
 // Initialisation de la liaison série (pour retourner les infos au moniteur série de l'ordi)
 Serial.begin(9600);
 Serial.println("Programme de test du DHT22");
 Serial.println("==========================");
 Serial.println();

 // Initialisation du DHT22;
 dht.begin();
}
 
// =================
// Boucle principale
// =================
void loop () {
 
 // Lecture des données
 float tauxHumidite = dht.readHumidity(); // Lecture du taux d'humidité (en %)
 float temperatureEnCelsius = dht.readTemperature(); // Lecture de la température, exprimée en degrés Celsius

 // Vérification si données bien reçues
 if (isnan(tauxHumidite) || isnan(temperatureEnCelsius)) {
 Serial.println("Aucune valeur retournée par le DHT22. Est-il bien branché ?");
 delay(2000);
 return; // Si aucune valeur n'a été reçue par l'Arduino, on attend 2 secondes, puis on redémarre la fonction loop()
 }

 // Calcul de la température ressentie
 float temperatureRessentieEnCelsius = dht.computeHeatIndex(temperatureEnCelsius, tauxHumidite, false); // Le "false" est là pour dire qu'on travaille en °C, et non en °F
 
 // Affichage des valeurs
 Serial.print("Humidité = "); Serial.print(tauxHumidite); Serial.println(" %");
 Serial.print("Température = "); Serial.print(temperatureEnCelsius); Serial.println(" °C");
 Serial.print("Température ressentie = "); Serial.print(temperatureRessentieEnCelsius); Serial.println(" °C");
 Serial.println();

 // Temporisation de 2 secondes (pour rappel : il ne faut pas essayer de faire plus d'1 lecture toutes les 2 secondes, avec le DHT22, selon le fabricant)
 delay(2000);
}
On réalise les premiers branchements des 2 pompes sur la carte arduino ainsi que le capteur d'humidité qui nous a d'ailleurs posé un peu problème car le capteur possède 4 branches et nous n'avons la possibilité que de brancher 4 branches nous avons donc demander de l'aide à monsieur Pulpytel pour nous aider pour ce branchement. Suite à ça nous avons recherché le code afin de faire fonctionner le capteur d'humidité et pouvoir récupérer les valeurs.

Code que nous avons réalisé :
#include <DHT.h>#include <stdio.h>#include <stdlib.h>#define brocheDeBranchementDHT 6    // La ligne de communication du DHT22 sera donc branchée sur la pin D6 de l'Arduino#define typeDeDHT DHT22             // Ici, le type de DHT utilisé est un DHT22 (que vous pouvez changer en DHT11, DHT21, ou autre, le cas échéant)// Instanciation de la librairie DHTDHT dht(brocheDeBranchementDHT, typeDeDHT);int objectif;const int relais_pompe1 = 3;const int relais_pompe2 = 4;// ========================// Initialisation programme// ========================void setup () {

 // Initialisation de la liaison série (pour retourner les infos au moniteur série de l'ordi)  Serial.begin(9600);  Serial.println("Programme de test du DHT22");  Serial.println("==========================");  Serial.println();  pinMode(BROCHE_CAPTEUR, INPUT_PULLUP);  pinMode(relais_pompe1,OUTPUT);  pinMode(relais_pompe2,OUTPUT); 

 // Initialisation du DHT22;  dht.begin();} // =================// Boucle principale// =================void loop () {

 // Lecture des données  float tauxHumidite = dht.readHumidity();              // Lecture du taux d'humidité (en %)  float temperatureEnCelsius = dht.readTemperature();   // Lecture de la température, exprimée en degrés Celsius printf("quel est le taux d'humidité souhaité ?"); scanf("%d",&objectif);  // Vérification si données bien reçues  if (isnan(tauxHumidite) || isnan(temperatureEnCelsius)) {    Serial.println("Aucune valeur retournée par le DHT22. Est-il bien branché ?");    delay(2000);    return;         // Si aucune valeur n'a été reçue par l'Arduino, on attend 2 secondes, puis on redémarre la fonction loop()  }  // Calcul de la température ressentie  float temperatureRessentieEnCelsius = dht.computeHeatIndex(temperatureEnCelsius, tauxHumidite, false); // Le "false" est là pour dire qu'on travaille en °C, et non en °F

 // Affichage des valeurs  Serial.print("Humidité = "); Serial.print(tauxHumidite); Serial.println(" %");  Serial.print("Température = "); Serial.print(temperatureEnCelsius); Serial.println(" °C");  Serial.print("Température ressentie = "); Serial.print(temperatureRessentieEnCelsius); Serial.println(" °C");  Serial.println();  // Temporisation de 2 secondes (pour rappel : il ne faut pas essayer de faire plus d'1 lecture toutes les 2 secondes, avec le DHT22, selon le fabricant)  delay(2000);  while(tauxHumidite!=objectif){if(tauxHumidite<objectif){  digitalWrite(relais_pompe1, HIGH);  digitalWrite(relais_pompe2, LOW);}else{  digitalWrite(relais_pompe1, LOW);  digitalWrite(relais_pompe2, HIGH);}}
Pour la seconde partie du code concernant la régulation des flux d'air sec et d'air humide, un code a été réalisé mais la prise en compte des données mesurées par le capteur dans ce code est un problème que nous n'arrivons pas à résoudre. Ainsi il est difficile de finaliser le code si nous n'arrivons pas à prendre en compte les données mesurées par le capteur.
- Tentative d'optimisation du flux d'air sec (26/01/2023)
                           

On sait que en moyenne le taux d'hydrométrie de l'air en France est de 50%. Dans le but de faire diminuer ce taux, nous avons eu l'idée de rajouter une bouteille pleine de riz qui d'après nous serait capable d'absorber une partie de l'humidité contenu dans l'air et ainsi nous permettre d'élargir notre gamme de régulation. Afin d'éviter que le riz entre dans nos tuyaux et les bouche nous avons ajouté un morceau de torchon qui nous permet de servir de filtre.
- Assemblage sur le support (26/01/2023)

- Réalisation de visuel avec l'imprimante laser (26/01/2023)
           

Afin de réaliser un projet un peu plus esthétique nous avons réalisé un petit visuel à l'aide de l'imprimante laser sur une petite plaquette de bois.

- Projet final assemblé (26/01/2023)

On peut observer sur cet image notre projet final, on a ainsi nos 2 pompes contrôlées en mode on/off à partir de Arduino. La pompe du bas correspond à notre flux d'air sec qui passe par le riz et arrive dans la bouteille de fuze tea ou les flux seront mélangés, la pompe du haut contrôle notre flux de gaz humide qui est humidifié dans notre bouteille verte qui est notre barboteur improvisé relié à la bouteille de fuze tea. Ainsi notre capteur d'humidité se trouve en haut de la bouteille de fuze tea. Si le capteur d'humidité se trouve en haut de la bouteille c'est pour éviter qu'il soit trop proche des arrivées de flux d'air sec et humide afin de ne pas fausser les valeurs.

En conclusion le barboteur a été testé et fonctionne, pareil pour nos 2 pompes de flux d'air humide et d'air sec. Cependant nous avons un problème concernant l'écriture du code et plus spécifiquement la mise en commun du code pour le capteur d'humidité et le code concernant la régulation de la pompe.

🌍 UE LU3ST062 - Atelier Fablab

Le stage "Fablab" propose à des équipes de 2 ou 3 étudiants de développer une approche de modélisation analogique et numérique autour d'un problème de Sciences de la Terre. 
Le but est de mettre au point, améliorer et utiliser des maquettes (non-dimensionnées) puis des modèles analogiques (dimensionnés) pour mettre en évidence un processus ou évaluer un paramètre critique. La discussion porte ensuite sur le passage des conclusions aux échelles géologiques. 
Concrètement la réalisation des montages passe par l'utilisation des ressources du Fablab (impression 3D, conception assistée par ordinateur ... ) et d'outils d'interfaçage (Arduino, MATLAB ... ) pour l'extraction de données des expériences.

Modèle analogique sable

Kathy Lazard, Amaury Leroy, Dan Rebibo et Alice Saugrain

   Partout sur notre planète, à des échelles variant de quelques centaines de mètres à des centaines de kilomètres, on peut observer nombre de fleuves avec chacun une dynamique qui leur est propre. Selon les pentes, la nature de leur substrat ou encore l'aménagement des territoires, les cours d'eaux varient. Cependant ils suivent tous des principes de sédimentologie et d'hydrologie. C'est ce que nous avons tenté de modéliser au cours de cette UE. Chaque semaine nous nous sommes réunis pour faire progresser notre modèle analogique des réseaux fluviatiles. Nous nous sommes inspirés du modèle existant produit par EmRiver, et nous avons cherché à le reproduire à moindre coût dans l'objectif d'utiliser cette table à des fins pédagogiques. 
(fig 1)Table existante EmRiver modèle em3
https://emriver.com/beyond-the-stream-table-and-using-the-emriver-em2-geomodel-at-gsa-2014-vancouver/
 [1] 
Pour cela nous sommes partis du cahier des charges suivant :
Notre table doit être :

un support d’exercices pour des séances de TP d’une durée de 3h niveau L1, répartis sur 1 semaine
utilisable en petits groupes de 4/machine

reproductible plusieurs fois, sans que le coût ne soit excessif
un modèle réduit déplaçable et démontable facilement
équipée d'un système hydrologique réparable et que l'on puisse brancher aisément
équipée d'un système d'eau en circuit fermé

Tout en gardant en tête ces attentes, nous avons dû réfléchir à des solutions pour minimiser les coûts et faire face aux problématiques que nous avons rencontré dans la conception de notre table. C'est ce que nous allons développer dans ce Wiki.
Plan :
I. La conception de la table
A/ La fabrication du bac
B/ Les modèles 3D
II. Assemblage et tests
III. Utilisation du modèle
Conclusion et perspectives

I. La conception de la table.

 A/ La fabrication du bac.
-Etanchéité

   Après l'obtention de la table en bois conçu par Loïc Labrousse aux dimensions souhaités (75 x 50 x 10 cm), nous avons aussitôt procédé à son bâchage dans le but de l'imperméabiliser. Pour ce faire, nous avons mis du scotch double face sur toute la surface interne de la table, avant de la recouvrir d'une bâche transparente. Bien que la bâche ne présentait aucune lacune, nous avons néanmoins veillé à vérifier l'efficacité de son action imperméabilisante en arrosant la table avec de grandes quantités d'eau et n'avons pas détecté de fuites (il s'est avéré par la suite qu'après plusieurs raclages, la bâche s'est abimée et a présenté 1 petit trou).
(fig 2) Photographie de la table en bois après bâchage :

-Angles de pente

  Un des paramètres que l'on peut mesurer dans un tel modèle analogique est l'impact de la variation d'une pente sur les modalités de formation d'un réseau fluviatile. Ainsi, dans un second temps, nous avons cherché à munir la table d'un dispositif de modulation de pente. EmRiver donnait des valeurs de pente allant de 0 à 3,5° pour ses modèles. Nous avons alors pensé à fabriquer des pieds ajustables. Nous avons alors remplacé les deux pieds en bois situés du côté de "l'orifice d'arrivé d'eau" par deux pieds en bois de même hauteur mais creux. L'objectif de ces derniers (que nous avons conçu nous même) et de pouvoir y insérer une barre métallique percée de trous, afin ultérieurement de pouvoir choisir le niveau de pente d'intérêt. Il a fallu faire des trous supplémentaires dans la barre métallique afin d'avoir plus de choix dans les valeurs d'angles.
Le problème majeur que l'on a eu c'est qu'on ne peut pas faire un trou circulaire de 20cm de longueur dans du bois. Il a donc fallu faire des trous avec une scie-cloche et coller 10 rectangles de bois les uns sur les autres (avec de la colle à bois) pour faire la hauteur voulue.

Avant (fig 3a)
Après (fig 3b)

Détail du pied et la barre d'acier à l'intérieur à insérer telle quelle, la partie la plus fine vers la table. La différence entre 2 trous correspond à un angle effectif de 0,86° sur la table.
(fig 4) Schéma du dispositif de pieds ajustables (4a) et photographie de la face inférieure de la table montrant les pieds incrustés à la table (B) :
4a)                                                              

 4b)

 

                           

Le résultat n'est pas très esthétique mais ce principe de pieds ajustables nous apparait comme étant un moyen efficace et peu coûteux pour ajuster la pente de la table (plusieurs valeurs prédéfinies possibles). Tel que nous les avions conçu, les pieds actuellement présent sur la table offrent jusqu'à 6 cm de battement de pied (soit 3,5° de pente). 
-Bac à décantation et circuit d'eau fermé

   Dans un troisième temps, nous nous étions lancé dans l'élaboration d'un bac à décantation. En effet, pour des raisons pratiques et écologiques, puis surtout pour permettre une pseudo-automatisation du modèle, l'alimentation en eau se fait suivant un schéma de circuit fermé. L'eau se jette dans la table, traverse le sable, puis doit pouvoir sortir au niveau de "l'orifice d'évacuation". Il faut donc, au débouché, un dispositif capable de réceptionner cette eau et les particules "sédimentaires" entrainées. Une fois réceptionnée (bac de décantation), l'eau (sans les particules, dorénavant décantées) est alors conduite vers un autre bac qui comporte la pompe (bac à pompe). La pompe absorbe alors l'eau et la conduit à nouveau en direction de l'orifice d'arrivée d'eau (et ainsi de suite).

(fig 5) Schéma simplifié illustrant la circulation de l'eau dans le système (circuit fermé) : 

                                                       Pour ce faire, nous nous étions munis de deux bidons d'eau déminéralisée vides, puis les avions fait se communiquer à mi hauteur via un tube creux métallique (pour permettre seulement à l'eau de transiter du bac de décantation vers le bac à pompe, dans l'objectif de permettre une alimentation en eau automatique de la pompe).  

(fig 6) Photographie du dispositif "Bac de décantation "-"Bac à pompe" :

Bac à pompe      

   

 Bac à décantation 

   Avant d'entreprendre un premier essai du modèle, nous avions évalué la fonctionnalité et la qualité de la pompe mise à notre disposition. Il en résultait que la pompe fonctionne et qu'elle a deux débits possibles. Nous avions alors décidé d'utiliser cette pompe, et l'avions donc munie d’un épais tube de polyuréthane pour lui permettre de propulser et de délivrer l'eau jusqu'à l'orifice d'arrivé d'eau. Par la suite, on aura vite fait de s'apercevoir que le débit de la pompe et par nature bien trop fort. Les dernières expériences seront alors réalisées avec le tube de polyuréthane pincé entre les deux bras d'un étau. 
B/ Les modèles 3D
Pour minimiser les coûts (et acquérir de nouvelles compétences), nous avons codé plusieurs pièces avec le logiciel Openscad pour les imprimer au FabLab.

Voici la liste des pièces que nous avons codé et imprimé :
1. Entrée d'eau : 2 pièces, un bec verseur et une pièce connectée au tuyau et fixée dans la planche (fig 7)
         

2. Energy Dissipator Unit (EDU), pièce qui réceptionne l'eau sortant du bec verseur et diminue donc son énergie cinétique. (fig 8)
         

3. Sortie d'eau : 2 pièces, une fixée au fond du bac et une interne dont le coulissement sert à faire varier le niveau d'eau du delta. (fig 9)
         

Les fichiers STL sont joints à ce Wiki.
Nous avons fait face à plusieurs difficultés dans le codage et les impressions de ces pièces : fragilité à l'impression, dimensions incompatibles, code effacé, ...
Pour la pièce de sortie d'eau, nous avons fait face à des difficultés de codage du filetage. Le but de cette pièce étant de ressembler à une vis, afin que un tour complet augmente ou diminue de 1cm la hauteur de l'eau accumulée dans le delta, nous avons codé le pas de vis mais le rendu était beaucoup trop fin pour résister aux forces qui allaient s'appliquer dessus.

En effet, nous voulions d'abord le coder en utilisant la fonction spiral_extrude : grossièrement, cette fonction utilise une forme en 2D (ici, nous voulions utiliser un cercle) et empile des copies de cette forme pour former une pièce en 3D. On peut faire s'enrouler cette structure autour d'un axe, c'est ce que nous pensions faire.
Seulement, la forme 3D est alors créée en empilant des formes 2D légèrement décalées les unes par rapport aux autres. De ce fait, plus la pièce s'enroule, plus le filetage est fin car les formes 2D se recouvrent moins. Utiliser la fonction linear_extrude produit donc un filetage très fin et fragile, qui de plus coulisse mal.
Il a donc fallu trouver une autre fonction sur Internet : la fonction spiral_extrude, qui fonctionne de manière similaire à linear_extrude mais permet aussi de choisir l'épaisseur du filetage. Néanmoins, nous avons cette fois-ci eu des problèmes à l'impression, les pièces n'étaient pas assez solides et ont cassé dès que nous avons tenté de les utiliser.
Pour l'entrée d'eau nous avions initialement pensé à une pièce de ce type : (fig 10)

Cependant après réflexion nous avons pensé que l'eau n'aurait peut-être pas assez du puissance pour remonter le "robinet" et ce n'est pas le plus efficace non plus pour contrôler la sortie d'eau. Nous avons donc modifié le design pour obtenir les 2 pièces suivantes : (fig 11)

Elles sont emboîtables et l'une peut tourner grâce à un système de complémentarité à l'intérieur.

Pour les pièces de sortie d'eau, la fragilité de la poignée nous a amené à utiliser tout le long de l'UE une version sans poignée qui, au final, était tout aussi pratique. Par ailleurs, à cause de la dilatation du plastique à l’impression nous avons dû agrandir les trous de la table. Ce paramètre est à prendre en compte avant d’imprimer les pièces.

  (fig 12)

II. Assemblage et tests
-Le 'sable' et ses proportions
Le 'sable' qui nous a été fourni par Loic Labrousse n'est pas du vrai sable mais des pastilles de plastique de différentes couleurs associées à différentes tailles, vendues par EmRiver. Ce 'sable' étant très cher nous avons voulu essayer avec du sable quartz de Fontainebleau. Mais l'esthétique du 'sable' était beaucoup plus intéressant.
Dimensions et quantité de chaque couleur : 
Tailles annoncées par EmRiver
Jaune : 1,4 mm de diamètre. Blanc : 1 mm. Noir : 0,7 mm. Rouge : 0,4 mm.
Dimensions réelles :
Jaune : majorité supérieure à 1,4, et les plus petits ne passent pas le filtre à 630 micromètres = à peu près la bonne taille.
Blanc : 50% de plus grand que 630 micromètres, 50% entre 630 et 425. = plus petit que prévu (1 mm).
Noir : majorité entre 630 et 425 = plus petit que prévu (0,7).
Rouge : plus petit que prévu, avec 90% environ entre 250 et 200 micromètres.

-Quantités à disposition
Jaune : 1,63 kg
Blanc : 16,25 kg
Noir : 7,8 kg
Rouge : 1,12 kg
Dans les expériences les particules les plus GROSSES partaient en premier illustrant l'effet Granola ou effet de fond de transport des particules.
Nous avons fait un mélange assez arbitraire des couleurs mais le résultat était assez joli. Nous voyions bien les méandres et visualisions bien les alternances de couleurs dans les coupes du delta et du lit de la rivière.
Mélange utilisé :

Jaune : 1,63 kg (tout le paquet)
Blanc : 6,65 kg
Noir : 1,55 kg
Rouge : 0,78 kg
Poids total de sable utilisé : 10,61 kg
(fig 13) Montage réel, avec dispositif permettant de filmer d'au-dessus de la table :

Nous voyions et visualisions bien les méandres, les alternances de couleurs dans les coupes du delta et du lit de la rivière.
Le 'sable' qui nous a été fourni par Loïc Labrousse n'est pas du vrai sable mais des pastilles de plastique de différentes couleurs associées à différentes tailles, vendues par EmRiver. Ce 'sable' étant très cher, nous avons voulu essayer avec du sable de Fontainebleau pour minimiser les coûts. Mais l'esthétique du plastique était beaucoup plus intéressante.
(fig 14) Comparaison sable de Fontainebleau et sable plastique

 vs. 
Nous avons laissé l’eau se creuser elle-même son lit, ce qui a donné des résultats de méandres différents à chaque fois.
(fig 15) Photos de différents tests

Nous avons aussi essayé uniquement avec du blanc et du noir en gardant la même proportion de blanc, vu que c'est celui qui part en 1er. Les méandres se voyaient bien, presque mieux, mais les coupes dans le delta étaient nettement moins pertinentes.
Lien Youtube pour voir des vidéos en timelapse : https://www.youtube.com/@Fablabsable
Verdict : il faut au moins 3 couleurs, le rouge n'est pas forcément nécessaire (sauf si vous voulez des méandres plus beaux).
Remarques :
Le problème de la pompe max 1000L/h : débit trop puissant même au minimum. Nous avons acheté une pompe à 200L/h mais débit non régulier ce qui la rend inutile. Nous sommes donc restés avec notre pompe initiale,nous avons serré le tuyau avec plusieurs pinces et au final avons carrément utilisé un étau pour un meilleur contrôle du débit.
(fig 16) Référence de la pompe :

Table pas droite : mettre du papier sous le pied du côté plus bas et vérifier avec le niveau à bulle.
On a résolu de tasser les bords pour éviter que la rivière ne se jette d'un coté de la table et qu'elle puisse faire plus facilement des méandres.
La table fuit aux jointures : mettre un bac sous la table pour récolter l'eau fuyarde.
Une inclinaison maximale de la table a donné de bon résultats au niveau de l'écoulement d'eau c'est pourquoi nous préconisons de régler les pieds aux trous les plus hauts (3,5° de pente).
Tentative d'imperméabiliser avec du plastique thermoformant infructeuse car rendu très gondolé. Tentative de pochoir à méandre infructueuse car tasse le sable.
III. Utilisation du modèle
Mode d'emploi :
(fig 17) Schéma du dispositif entier

Voici énoncé sous forme de notice la façon dont notre prototype s’utilise.
Il peut être utilisé comme instructions pour un TP.
1- Placer le bac de décantation (bac avec la plus grande ouverture) sous la sortie d’eau. Veiller à ce que le bac à pompe qui lui est associé soit sous la table mais accessible pour placer et manipuler la pompe. Placer donc la pompe.

2- Humidifier le sable en versant 4,5 L d’eau en plusieurs fois, et ce, près de l’entrée d’eau dans le bac.

3- Mélanger le sable pour homogénéiser la granulométrie à l’échelle du bac. Attention, NE PAS LE TASSER !
4- Tasser le sable localisé au niveau des 5 cm les plus proches des bords latéraux de la table : cela permettra de maintenir le cours d’eau loin des bords de la table.
5- Aplanir le reste du sable (celui encadré par les 5 cm tassés à l’étape 4), et ce, SANS LE TASSER. En effet, il est crucial de laisser une certaine hétérogénéité. Veiller à laisser une zone sans sable d’environ 25 cm du côté de la sortie d’eau : elle représentera le delta (le passage “continent” - “delta” doit être progressif).
(fig 18)
6- Placer l’EDU et l’entrée d’eau, de manière à ce que le bec de l’entrée d’eau soit posé sur le cylindre central de l’EDU. Si besoin, tasser du sable sous l’EDU pour le surélever, afin que la sortie de l’EDU soit au niveau de la surface du sable.
(fig 19)

7- Verser 9L d’eau dans le bac de décantation à travers la sortie d’eau (utiliser un entonnoir). Verser en plusieurs fois, cela donnera le temps à l’eau de passer du bac de décantation au bac de la pompe, évitant ainsi tout débordement !
8- Régler la pente via les pieds ajustables de la table. Vérifier que les pieds sont à la même hauteur.

9- Placer le dispositif vidéo au-dessus de la table, de telle sorte que toute la table puisse être filmée.
10- Vérifier que la table n’est pas penchée, en haut comme en bas, à l’aide d’un niveau de géomètre : la moindre variation peut avoir beaucoup d’effet ! Si besoin, placer des cales (en papier, ça suffit) sous les pieds jusqu’à ce que la bulle du niveau se trouve bien au centre.
11- Serrer l’étau pour avoir un débit de 10 mL/seconde (0,5 cm d’écartement).
(fig 20)

Dispositif de serrage du tuyau avec un étau.
12bis- 2 choix :
a- Laisser l’eau se faire son chemin -> ne rien faire
b- Suivre l'évolution d’un méandre -> pré tracer un chemin dans le sable
13- Lancer l’expérience en branchant la pompe. C’est parti !
14- Lorsque votre expérience est conclue, débrancher la pompe.

15- Laisser l’eau du delta s’évader dans le bac de décantation (attendre 5 minutes). Pas d’inquiétudes si du sable est emporté.
16- S’il vous l’est demandé, réaliser des coupes.
17- Retirer de la table le tuyau d’alimentation en eau.

18- Retirer l’eau du bac de décantation.

19- Ajuster les pieds de la table de sorte que le pendage soit nul.

20- Mélanger grossièrement le sable, de sorte que le groupe suivant puisse débuter l’expérience avec un sable hétérogène et sans avoir connaissance du résultat attendu.

Conclusion et perspectives

Notre objectif avec ce projet était de concevoir un système de modélisation de réseau fluviatile pour un coût plus raisonnable que le modèle EmRiver. Il devait être suffisamment petit pour être utilisé en plusieurs exemplaires dans la même salle de classe, mais assez grand pour être observable par un groupe de 4 élèves ; l’eau et le “sable” devaient être conservés dans le système avec un circuit fermé.
Tout d’abord, au terme de ce projet, nous avons une expérience qui fonctionne et nous pouvons observer des phénomènes intéressants avec. 
Nous avons d’abord utilisé une table en bois de 75 x 50 x 10 cm, bâchée pour éviter la déformation et les fuites mais nous pensons qu’utiliser une table plus grande, de 120 x 60 x 15 cm serait plus judicieux, pour pouvoir former plus de méandres (plus de sable que ce que nous avons utilisé sera nécessaire).
Pour améliorer la table/bac, utiliser un autre matériau pourrait contrer les problèmes d'étanchéité : plexiglass sur mesure (solide, imperméable, transparent, mais d’autant plus cher que des plaques de 8 mm d’épaisseur seraient idéales), bac en plastique (moins esthétique mais beaucoup moins coûteux) ou garder du bois mais peint, verni ou avec une bâche de qualité (bâche ETM par exemple). Acheter des pieds ajustables similaires à ceux que nous avons fabriqués seraient aussi indiqué.
La circulation d’eau pourrait elle aussi être améliorée, notamment selon deux aspects. Premièrement, la pompe que nous utilisons est à débit trop important et inconstant : la remplacer par une pompe plus petite et/ou ajouter un débit-mètre réglable pour contrôler finement le débit serait utile. En second lieu, le système de décantation à deux bacs fonctionne bien mais il est difficile de récupérer le sable car celui-ci est mouillé ou collé aux parois. Une solution serait de placer un grillage horizontal assez haut dans le premier bac, de manière à retenir le sable au-dessus du niveau de l’eau et ainsi lui permettre de sécher.
Enfin, les impressions 3D sont fonctionnelles et suffisantes, mais souvent peu solides ; nous pourrions les imprimer en résine mais les déformations éventuelles risquent d’empêcher certaines pièces d’être complémentaires. Réimprimer l’EDU avec une fente externe moins longue pourrait aussi être utile mais pas nécessaire, tout comme raccourcir la sortie d’eau.
Bibliographie
[1] « Emriver Stream Tables & Hydraulic Flumes ». Emriver, https://emriver.com/.
Remerciements
Un grand merci à Loic Labrousse et à Pierre Théry qui nous ont aidé et encadré tout au long du projet. Merci également a Damien Do Couto qui nous a fait un retour sur la manip et sur son utilisation possible en TP. Merci aussi à l'équipe du Fablab Polytech qui nous a appris à utiliser les imprimantes 3D pour les impressions de pièces.

Carnet de bord
Séance 0 (vendredi 20 janvier) :
Présentation de l’UE et du projet sable.
Nous avons visité le fablab puis nous avons fait un brainstorming sur comment concevoir la table et son système hydraulique avec les différents paramètres à prendre en compte.

Séance 1 (vendredi 27 janvier) :

TEST 1

→ bac à tester en bois recouvert bâche, connaître dimensions idéales et syst hydro ouvert
pbm : avec la quantité de sable, quelle épaisseur ? Est-ce qu’on voit assez de phénomène avec cette épaisseur ?

rapports L/l de la boîte pour optimiser les phénomènes ?
Savoir le volume de sable qu’on a et celui nécessaire. -> Taille de la boîte.
Avoir notre propre grille de tailles de grains (savoir la granulométrie de chaque type de grain).
Idée finale : savoir les dimensions de la boîte qu’on va prendre.

Il nous fallait faire une révision du diamètre des sables mis à notre disposition, en vue de vérifier si les valeurs fournies par le site sont en adéquation avec ce que nous disposons (rapport qualité).
Jaune : 1,4 mm de diamètre.
Blanc : 1 mm.
Noir : 0,7 mm.
Rouge : 0,4 mm.
Toutes les particules ont la même masse volumique, égale à 1,5 g/mL.
Donc si on prend une table de 75*50 centimètres, il faut 28,125 kg de sable.
Rouge : plus petit que prévu, avec 90% environ entre 250 et 200 micromètres.
Noir : majorité entre 630 et 425 = plus petit que prévu (0,7).
Blanc : 50% de plus grand que 630 micromètres, 50% entre 630 et 425. = plus petit que prévu (1 mm).
Jaune : majorité supérieure à 1,4 et les plus petits ne passent pas le filtre à 630 micromètres = à peu près la bonne taille.
Donc au sein de la même couleur, on a une granulométrie hétérogène.
De plus, la plupart des grains sont globalement plus petits que les valeurs données (tout sauf le jaune).
La courbe granulométrique qui a résulté de la séance n’est pas assez précise car nous nous intéressions seulement à où s'arrêtait la majorité des grains.
objectifs séance 2 :

-Avec un prototype de bac, tester les écoulements d’eau pour savoir l’épaisseur de sable à mettre

-Il faudrait re-tamiser les différents sables pour pouvoir faire notre propre courbe granulométrique en cumulé (les tailles de grains observées diffèrent de celles indiquées).
Séance 2 (vendredi 3 février) :

Etanchéité du bac (Kathy + Dan)

Loic Labrousse nous a fait un prototype de table pour tester les écoulements d’eau. La priorité a été de rendre la table étanche. Après avoir mesuré toute la surface du bac à couvrir et donc les dimensions de la bâche à utiliser, nous avons collé du scotch double face pour coller la bâche sur la table. Cela nous a pris plus de temps que prévu en raison de la précaution lors de l’utilisation du scotch double face, les points les plus critiques à étanchéifier étant les angles.
Avant

Après

L’autre possibilité est d’avoir directement une table en plexiglass ce qui ôterait cette étape d'étanchéification mais ça coûte cher.

Il n’y a plus qu’à tester vraiment la table avec de l’eau la semaine prochaine.
Selon le site emriver.com qui présente les modèles dont nous nous inspirons en version cheap, l'angle d’inclinaison de la table est de 3 degré et celui-ci doit pouvoir varier entre 0 et 3,5. Ce qui veut donc dire qu’on doit pouvoir surélever un côté de la table jusqu’à 6 cm environ. Donc l’autre objectif de la prochaine séance sera de voir comment on pourra le faire.

Création des pièces pour entrée et sortie d'eau (Alice + Amaury)

Pendant cette séance nous avons aussi découvert le logiciel Openscad avec lequel nous avons tenté de créer le système de sortie d’eau du bac. L’idée était de faire une sorte de vis creuse que l’on ferait tourner d’un tour (360°) pour modifier la hauteur de 1cm. Le trou d’évacuation d’eau étant au bout de cette vis, cela permet donc de modifier et contrôler la hauteur d’eau au niveau de la zone du delta. La première version du code est la suivante :

SORTIE D'EAU (cliquer sur le triangle pour voir le code)

// valeurs vis externe
color1 = "LightBlue"
h0 = 100
r0 = 22
fn = 36
tr2 =

// vis externe
difference(){

union(){

 color(color1) cylinder(h0, r0, r0, true, $fn = fn);

 translate([0, 0, 49]) color(color1) cylinder(2.9, 28, 28, true, $fn = 36);

translate([0, 0, -62.5]) color(color1) cylinder(25, 16, 22, true);

 translate([0, 0, -87.5]) color(color1) cylinder(25, 16, 16, true);

}

cylinder(101, 19, 19, true, $fn = 36);

 translate([0, 0, -62.5]) cylinder(26, 13, 19, true);
translate([0, 0, -87.5]) cylinder(26, 13, 13, true);

linear_extrude(height = 100, center = true, convexity = 10, twist = 3600)
translate([20, 0, 0]) circle(r = 1.5);

}
// vis interne
difference(){

union(){

 translate([0, -17.5, 70]) color("Pink") cylinder(30, 1.5, 1.5, true);

 translate([0, 0, 85]) rotate(a=[90, 90, 0]) color("Pink") cylinder(38, 1.5, 1.5, true);

 translate([0, 17.5, 70]) color("Pink") cylinder(30, 1.5, 1.5, true);

 translate([0, 0, 2.5]) color("Pink") cylinder(105, 19, 19, true, $fn = 36);
//    cylinder(100, 21.3, 21.3, true, $fn = 36);

 linear_extrude(height = 100, center = true, convexity = 10, twist = 3600, $fn = 36) translate([20, 0, 0]) circle(r = 1.3);

}

translate([0, 0, 2.5]) cylinder(106, 16, 16, true, $fn = 36);

linear_extrude(height = 100, center = true, convexity = 10, twist = 3600, $fn = 36) translate([20, 0, -2.6]) rotate([90, 0, 0]) circle(r = 1.3);

}

Cependant, nous avons été confrontés à un problème inattendu : en étirant le cercle pour réaliser le filetage de vis, celui-ci s’est aplati, ce qui donnait un filetage extrêmement fin et fragile. Pour remédier à ce problème, nous avons tenté plusieurs approches : à ce jour (07/02), la réflexion est encore en cours.

Hypothèses :

1) Essayer de prendre une sphère et de d'utiliser la fonction linear_extrude pour allonger un objet 3D.
Résultat : la fonction linear_extrude ne supporte pas les objets 3D.

2) Réduire l’échelle de l’ensemble pour voir si l’objet était “plus rond” à plus petite échelle.
Résultat : pas plus rond, c’est lié à comment marche la fonction.
En effet, linear extrude empile juste des formes 2D (=extrusion de la forme 2D d’origine) en les déplaçant les unes par rapport aux autres en fonction du twist : ici un cercle + un cercle légèrement décalé au-dessus + un autre cercle encore décalé au-dessus ...
Donc grand twist = grand décalage entre les formes = faible épaisseur quelle que soit l’échelle.

3) Obtenir la crête souhaitée en ajoutant un cylindre là où elle devrait être, puis en soustrayant à ce cylindre, via la fonction difference(), des spirales obtenues par linear_extrude.
Résultat : même problème que pour créer directement la crête, c’est à dire que twist trop grand = crête trop fine. Autrement dit, on va pas passer la nuit (et 50 lignes de programme) à virer des spirales.

4) On part sur 4 crêtes sur la vis (on adapte donc la forme de la vis externe). On augmente ainsi le pas de vis pour épaissir la crête = crêtes plus résistantes.
On ajoute donc :

linear_extrude(height = 100, center = true, convexity = 10, twist = tw1, $fn = 36) translate([20, 0, 0]) circle(r = 1.3);

linear_extrude(height = 100, center = true, convexity = 10, twist = tw1, $fn = 36) translate([0,20, 0]) circle(r = 1.3);

linear_extrude(height = 100, center = true, convexity = 10, twist = tw1, $fn = 36) translate([-20, 0, 0]) circle(r = 1.3);

linear_extrude(height = 100, center = true, convexity = 10, twist = tw1, $fn = 36) translate([0, -20, 0]) circle(r = 1.3);
Résultat : ça marche … mais 4 crêtes sont inutiles ici (?), car les contraintes sont faibles sur la vis (sinon, utiles pour la solidité de l’ensemble je crois). On enlève 2 crêtes, pour ne garder que :

linear_extrude(height = 100, center = true, convexity = 10, twist = tw1, $fn = 36) translate([20, 0, 0]) circle(r = 1.3);

linear_extrude(height = 100, center = true, convexity = 10, twist = tw1, $fn = 36) translate([-20, 0, 0]) circle(r = 1.3);
08/02/2023
Après 4 tentatives, on a un modèle qui tient la route. Maintenant, place au softcoding :) Et voilà le code digne de ce nom, où toutes les tailles et translations sont définies selon la hauteur du grand cylindre bleu :

//CODE NECESSAIRE POUR IMPRIMER LES 2 PIECES
//valeurs générales

colorext= "LightBlue";
colorint= "Pink";
fn= 36;
//On notera que ces 3 valeurs ne servent qu'à l'aspect visuel : la couleur ne sera pas nécessaire à l'impression, et la définition permettra un rendu plus harmonieux (et des cercles plus ... ronds).

//valeurs gros cylindre (servent de base à toutes les autres valeurs, surtout hbigtube)
hbigtube= 100;
rbigtube= 0.22*hbigtube;

//valeurs vide gros cylindre
hemptybigtube =1.01*hbigtube;
remptybigtube= 0.19*hbigtube;
twistroom= 9*hemptybigtube;

//explication : on veut que pour accueillir la crête de la vis, la rainure ( "room" dans les noms de valeurs) fasse toute la longueur du gros cylindre ("bigtube"). Donc on aurait twistroom= 5.4 (parce que 540° de twist)*hbigtube.

// Sauf que le cylindre plat au sommet ("toptube") est posé légèrement plus haut que le sommet du "bigtube" ... mais pas de problème ! Le tube de vide qui les rend creux ("emptybigtube") est plus grand que le "bigtube" pour rendre "bigtube" et "toptube" creux en même temps :)

// Résultat des courses : hroom = hemptybigtube permet de se simplifier la vie, en donnant hroom = 101 alors que h(bigtube+toptube)= 100.9. Ceci étant fait, on doit éviter de perdre en précision sur la rainure : en calculant le twist sur hemptybigtube, on peut garder le twist propotionnel à la taille des tubes, donc toujours la même ligne comparativement au tube.
conv= 10;
//CODE NECESSAIRE EN PLUS POUR IMPRIMER LE SUPPORT
//valeurs pièce externe (support)

//valeurs top cylindre

transxtoptube= 0;
transytoptube= 0;
transztoptube= 0.49*hbigtube;
htoptube= 0.029*hbigtube;
rtoptube= 0.28*hbigtube;

//valeurs cône et petit tube
transxcone= 0;
transycone= 0;
transzcone= -0.625*hbigtube;
hcone= 0.25*hbigtube;
rconelow= 0.16*hbigtube;
rconetop= 0.22*hbigtube;
transxsmolcone= 0;
transysmolcone= 0;
transzsmolcone1= -0.79*hbigtube;
transzsmolcone2= -0.87*hbigtube;
transzsmolcone3= -0.95*hbigtube;
hsmolcone1= 0.08*hbigtube;
hsmolcone3= 0.09*hbigtube;
rsmolconetop= 0.16*hbigtube;
rsmolconelow1= 0.15*hbigtube;
rsmolconelow3= 0.14875*hbigtube;

//valeurs vide gros cylindre (les pas fondamentales)
transxemptybigtube= 0;
transyemptybigtube= 0;

//valeurs vide cône et vide petit tube
hemptycone= 0.26*hbigtube;
remptyconelow= 0.13*hbigtube;
remptyconetop= 0.19*hbigtube;
hemptysmolcone= 0.26*hbigtube;
remptysmolcone= 0.13*hbigtube;

//Valeurs rainure d'insertion vis ("room")
hroom= hemptybigtube;
transxroom1= 0.19*hbigtube;
transxroom2= -transxroom1;
transyroom= 0;
transzroom= 0;
rroom= 0.017*hbigtube;

// pièce externe (support)
difference(){

union(){

 color(colorext) cylinder(hbigtube, rbigtube, rbigtube, true, $fn = fn);

 translate([transxtoptube, transytoptube, transztoptube]) color(colorext) cylinder(htoptube, rtoptube, rtoptube, true, $fn = fn);

translate([transxcone, transycone, transzcone]) color(colorext) cylinder(hcone, rconelow, rconetop, true, $fn= fn);

translate([transxsmolcone, transysmolcone, transzsmolcone1]) color(colorext) cylinder(hsmolcone1, rsmolconelow1, rsmolconetop, true, $fn= fn);

translate([transxsmolcone, transysmolcone, transzsmolcone2]) color(colorext) cylinder(hsmolcone1, rsmolconelow1, rsmolconetop, true, $fn= fn);

translate([transxsmolcone, transysmolcone, transzsmolcone3]) color(colorext) cylinder(hsmolcone3, rsmolconelow3, rsmolconetop, true, $fn= fn);

}

cylinder(hemptybigtube, remptybigtube, remptybigtube, true, $fn = fn);
 translate([transxcone, transycone, transzcone]) cylinder(hemptycone, remptyconelow, remptyconetop, true, $fn= fn);
translate([transxcone, transycone, transzsmolcone2]) cylinder(hemptysmolcone, remptysmolcone, remptysmolcone, true, $fn= fn);

linear_extrude(height = hroom, center = true, convexity = conv, twist = twistroom, $fn= fn) translate([transxroom1, transyroom, transzroom]) circle(r = rroom);

linear_extrude(height = hroom, center = true, convexity = conv, twist = twistroom, $fn= fn) translate([transxroom2, transyroom, transzroom]) circle(r = rroom);

}

//CODE NECESSAIRE EN PLUS POUR IMPRIMER LA VIS
//valeurs pièce interne (vis)

//valeurs cylindres anse
transxlattube= 0;
transylefttube= 0.175*hbigtube;
transyrighttube= -transylefttube;
transzlattube= 0.7*hbigtube;
transxmidtube= 0;
transymidtube= 0;
transzmidtube= 0.85*hbigtube;
rotxmidtube= 90;
rotymidtube= 90;
rotzmidtube= 0;
hlattube= 0.3*hbigtube;
rlattube= 0.03*hbigtube;
hmidtube= 0.4*hbigtube;
rmidtube= 0.03*hbigtube;

//valeurs gros cylindre interne
transxbigint= 0;
transybigint= 0;
transzbigint= 0.025*hbigtube;
hbigint= 1.05*hbigtube;
rbigint= 0.19*hbigtube;

//valeurs crête vis
hvis= hbigtube;
rotxvis= 0;
rotyvis= 0;
rotzvis= -4;
transxvis1= 0.19*hbigtube;
transxvis2= -transxvis1;
transyvis= 0;
transzvis= 0;
rvis= 0.013*hbigtube;

//valeurs vide gros cylindre interne
transxemptybigint= 0;
transyemptybigint= 0;
transzemptybigint= 0.025*hbigtube;
hemptybigint= 1.06*hbigtube;
remptybigint= 0.16*hbigtube;

// pièce interne (vis)
difference(){

union(){

translate([transxlattube, transyrighttube, transzlattube]) color(colorint) cylinder(hlattube, rlattube, rlattube, true, $fn= fn);

translate([transxlattube, transylefttube, transzlattube]) color(colorint) cylinder(hlattube, rlattube, rlattube, true, $fn= fn);

translate([transxbigint, transybigint, transzmidtube]) rotate(a=[rotxmidtube, rotymidtube, rotzmidtube]) color(colorint) cylinder(hmidtube, rmidtube, rmidtube, true, $fn= fn);

translate([transxbigint, transxbigint, transzbigint]) color(colorint) cylinder(hbigint, rbigint, rbigint, true, $fn = fn);

   rotate([rotxvis, rotyvis, rotzvis]) linear_extrude(height = hvis, center = true, convexity = conv, twist = twistroom, $fn = fn) translate([transxvis1, transyvis, transzvis]) circle(r = rvis);

   rotate([rotxvis, rotyvis, rotzvis]) linear_extrude(height = hvis, center = true, convexity = conv, twist = twistroom, $fn = fn) translate([transxvis2, transyvis, transzvis]) circle(r = rvis);

}

translate([transxemptybigint, transyemptybigint, transzemptybigint]) cylinder(hemptybigint, remptybigint, remptybigint, true, $fn = fn);
}
ENTREE D'EAU
//aucune idée des diamètres de tuyaux donc il faudra soft-coder les diam des cylindres pour ajuster selon le tuyau mais en gros j'pense c'est pas mal

union(){
difference(){

rotate([0, 65, 0])cylinder(40, 5, 12);

translate([-1, 0, 0])rotate([0, 65, 0])cylinder(42, 3, 10);

translate([45, 0, -24])cylinder(52, 10, 10);}
difference(){
translate([30, 0, 15.5]) rotate([0, 90, 0])cylinder (30, 12, 12);

translate([29, 0, 15.5]) rotate([0, 90, 0])cylinder(30, 9, 9);

translate([45, 0, -27.5])cylinder(48, 10, 10);}

}
difference(){

translate([45, 0, -23])cylinder(50, 12, 12);

translate([45, 0, -24])cylinder(52, 10, 10);
translate([29, 0, 15.5]) rotate([0, 90, 0])cylinder(32, 10, 10);}

Après avoir soft codé ce petit bijou d'inspiration, on le sépare en 2 fichiers puisqu'il y a 2 pièces à imprimer : en effet, il faut pouvoir faire tourner le robinet pour que l'eau arrive dans le système avec un certain angle. Les 2 pièces sont maintenues grâce à un élément supplémentaire sur le tube traversant la paroi de la table ; cet élément vient s'encastrer dans le tube mobile et permet ainsi de le maintenir.
Séance 3 (10/02)
Dan et Kathy

Nous avons dans un premier temps vérifié la fonctionnalité/qualité de la petite pompe à eau que Pierre nous a fourni. Il en résulte que :

Elle fonctionne,

Le débit de propulsion de l’eau est réglable (du plus ou moins fort débit),

Son efficacité est maximale lorsqu’elle est complètement immergée dans l’eau,

Nous l’avons munie d’un épais tube polyuréthane plus long que l’initial. En effet, la longueur du tube permet d’atteindre l’orifice situé à l’avant du bac.

Le système hydraulique sera en circuit fermé. L’eau à la sortie de la table servira à garder la pompe immergée.

Cependant, la pompe à notre disposition fonctionne au branchage. Autrement dit, dès que l'engin est branché, il se met en marche. Or, ce n’est absolument pas pratique, et sûrement pas professionnel dans un cadre pédagogique. Il faudra donc à un moment ou un autre penser à y insérer un système d’interrupteur manuel classique, ou alors changer de pompe.

Nous avons dans un second temps tester l’étanchéité de la table précédemment mise sous bâche (cf séance du 03/02/2023). Pour ce faire, nous avons rempli un gros bidon d’eau du robinet que nous avons déversé dans le bac. Il en résulte que :

Environ 99% de la table est étanche. La bâche que nous avions placée est efficace.

L’essai a révélé une petite lacune dans la bâche, nous l’avons comblé avec du ruban adhésif.

Notons qu'au niveau du trou d'évacuation de l’eau, les tuyaux n’étant pas encore disposés, de l’eau à pénétrer le bois. Cela met en évidence l’importance d’une étanchéité sans faille. En effet, comme on le voit sur l’image ci-dessous, l’eau a imbibée le bois et s’est répandue en auréole.

Dans un troisième temps, nous avons réfléchi à un système pratique, efficace et peu coûteux qui permettrait d’ajuster la pente de la table (plusieurs valeurs prédéfinies possibles). Nous avons pensé à un système simple de pieds ajustables pour les deux pieds situés au niveau de la future entrée d’eau qui nous permettrait d’avoir jusqu’à 6 cm de battement du pied (donc jusqu'à 3,5° de pente de la table). 

Schéma théorique du pied à hauteur ajustable :

Pour équilibrer l’ajout, nous remplacerons donc les deux autres pieds de la table par des pieds simples (non ajustables) de même longueur. Cette augmentation de la hauteur des 4 pieds permet dans un même élan de régler un souci : alias la difficulté d’accès au dessous de la table. En effet, la table initiale est bien trop basse pour manipuler pompe, tuyaux…

On a donc fait les deux pieds plus grands dont l’objectif était de les rendre creux et rentrer un tube en métal qui plus ou moins enfoncé permettrait l'élévation d’un côté de la table.
Problème : on ne peut pas faire un trou dedans avec la perceuse à scie à cloche.

Résultat après la scie à cloche sur le pied de gauche

On a donc opter pour percer et découper des morceaux de bois de 2 cm d’épaisseur qu’on collera ensuite ensemble. Le tube en métal passera dedans. On a fait plusieurs trous mais on s’est arrêtés car la batterie de la perceuse était morte.

Perspectives :

A la prochaine séance, il nous faudra poursuivre et finaliser les pieds de table, puis les incruster à cette dernière. Ensuite, avec la balance que Pierre nous aura apporté, nous pourrons peser la masse de sable totale dont nous disposons.

Séance 3 (17/02)
Alice et Amaury (partie inutile au final)

Aujourd’hui, nous cherchons à préparer le bac de décantation où arriveront l’eau et les grains de sable transportés une fois sortis du plateau de modélisation.

Problématique 1 : éviter que les tuyaux se baladent sous la pression de l’eau.

On va donc … faire des pièces à imprimer, pour changer :)
How it looks :

Cette pièce sera placée sur le bord du bac de décantation et maintiendra le tuyau amenant l’eau à la modélisation, tuyau qui passera par le trou cylindrique de diamètre 1,5 cm.
D’ailleurs, on ne le voit pas sur cette capture d’écran mais une encoche est présente pour venir placer la pièce directement sur le bord du bac de décantation.

Pour ce qui est de l’eau sortant de la table de modélisation, on se demande s’il faut vraiment un tuyau ou si laisser tomber l’eau directement serait viable.
Autrement dit, est-ce que ça gicle partout si on met pas de tuyau ?
Etant donné que la sortie d’eau aura une hauteur assez stable (c’est l’autre côté de la table qui monte ou descend pour former la pente), ne pas mettre de tuyau est viable uniquement si la hauteur de base n’est pas trop importante … reste à tester la limite.

Contrainte 2 : éviter de renvoyer du sable dans le système/de boucher la pompe.
En bref on veut que le bac de décantation … décante.

Tout ça en sachant que la pompe ne fonctionne de manière optimale que si elle est complètement immergée (il faut donc garantir une hauteur d’eau relativement importante, d’au moins 10 cm) et que si la longueur de tube entre la pompe et l’entrée d’eau est trop importante, on n’aura plus assez de pression d’eau.

Notre idée de base était d’entourer la pompe d’un grillage au maillage suffisamment petit pour empêcher le sable d’entrer, mais ce serait assez peu pratique à fabriquer.
On peut faire plus simple néanmoins : on place un grillage de même maillage mais cette fois-ci, on le prend de la largeur et hauteur du bac, et on le place de manière à séparer le bac de décantation en 2.

On se retrouve ainsi avec une zone où l’eau est chargée en sable, et une autre où elle n’en contient plus et où se trouve la pompe ; le grillage vertical permet au sable de décanter et de peu s’accumuler en hauteur.

Dimensions du bac de décantation :

Assez grand pour être divisé en 2, avec assez de place derrière le grillage pour mettre la pompe et une quantité d’eau suffisante.
Donc on pourrait partir sur 70 cm de long*20 cm de large*20 cm de haut ; le grillage serait placé après 50 cm (par exemple), laissant un cube de 20 cm de côté où l’eau serait prélevée par la pompe.

Pour des raisons de simplicité, nous n'avons au final pas utilisé ce modèle. Il nous a suffi de percer 2 bidons, l'un accueillant l'eau provenant de la table et l'autre contenant la pompe renvoyant l'eau dans le système. Ces deux bidons ont été reliés par un tube pour que l'eau puisse circuler, avec des joints pour étanchéifier l'ensemble.

Conception de la table

Nous avons continué ce que nous avions fait la semaine dernière c’est-à-dire que nous avons refait tous les pieds de la table en plus long et plus gros, dont les deux à hauteur ajustable.
Nous avons fait des trous de chaque côté de la barre (entre ceux déjà préexistants) ainsi qu’un dans le bois pour pouvoir faire passer une tige à travers tous les trous

Les trous sont espacés tous d’environ 1,5 cm ce qui fait, par trou, une différence de 0,86° dans la pente de la table.
Alice a codé des cales à mettre sous le pied en fonction de l'intensité de l’inclinaison.
Pour la version finale nous choisirons sûrement un espacement qui permettra de changer la pente de 1, 2 ou 3° (ce sera plus simple pour les expériences).

Aperçu des différents composants du pied ajustable (bois creux + barre d’acier trouée)

Résultat final de la table vue à l’envers

La prochaine fois :
Il reste 3 trous a faire dans une des barres d’acier et normalement la table sera prête à être testée avec de l’eau et du sable.

Séance 4 du 24/02
Alice & Amaury
Lors de cette séance, les objectifs étaient de contrôler le rendu des premières impressions.

Observations :
- la poignée de la vis interne est trop fragile

- il faut faire attention au coefficient de dilatation lors de l'impression : les pièces censées s'emboîter ont un problème de diamètre.

Pour résoudre ces deux problèmes nous avons donc modifié les pièces et leurs dimensions dans open scad et lancé des réimpressions.
- la vis externe ne rentre pas dans le trou de la planche.

Solution: limer.

Par ailleurs nous avons profité de cette séance pour coder des pièces pour le tuyau reliant les deux bacs sous la table (voir partie de Kathy & Dan) car les pièces en métal achetées n'avaient pas les bonnes dimensions entre elles. Soit elles seront ré-achetées soit nous imprimerons les pièces codées.

Update final : cette partie est inutile aussi car les pièces en métal sont utilisées.
Dan et Kathy
On a fini les trous dans l’acier, donc les pieds réglables, c’est réglé.

On s’est ensuite attardé sur comment faire le bac de décantation avec la pompe. Pierre nous a ramené 2 bidons et au lieu de les coller on a préféré faire un trou dans les deux et les relier par un tube (les essais ont révélé après que l'étanchéité de ce passage était bof bof). On a aussi enlevé une partie du haut d’un des bidons pour pouvoir mettre la pompe dedans et faire passer le tuyau.

Ensuite le moment tant attendu : celui de tester les écoulements d’eau sur la table avec le fameux ‘sable’, c'est-à-dire les paillettes de plastique. On a mis le ‘sable’ blanc, celui de plus grosse granulométrie et une espèce de latte en plastique inclinée pour empêcher le sable de partir dans le trou d’évacuation de l’eau et pour faire la limite avec le delta. Au final on l’a retiré ça ne servait à rien car l’eau et le sable passaient par en dessous Et finalement le système de décantation en dessous.

Schéma de la circulation d'eau dans le système
Ça ne s’est pas du tout passé comme prévu même en inclinant la table :
-On a dû diminuer le débit avec une pince sur le tuyau sortant sinon peu importe le réglage de débit de la pompe c'était trop fort alors qu’on observait un changement de débit quand on a testé la pompe toute seule.
-L’eau au lieu de couler ne faisait qu’imbiber et creuser un trou dans le sable
-On devait rajouter de l'eau dans le bac de la pompe vu que l'eau sur la table ne voulait pas descendre et en plus la pompe avait du mal à rester immergée.
Le comportement du sable en question était très bizarre et on se demande si c’est pas dû au fait que justement ce ne soit pas du vrai sable. Pourtant aux US ça marche donc on sait pas pourquoi.

- en augmentant le débit finalement ça coulait et ça nous a creusé un chemin dans le ‘sable’ mais au final on a eu une inondation par terre

-Du 'sable' arrivait dans le bac de la pompe risquant de boucher celle-ci
Et gros problème : le 'sable' COLLE BEAUCOUP TROP PARTOUT donc trèès compliqué pour nettoyer derrière (y en a même qui s'est collé sur le haut du bidon de décantation).

A améliorer :

On va utiliser du sable de quartz au prochain essai pour voir si le comportement des particules est différent de celles en plastique
Séance 5 (10/03)
On a pris du sable de quartz pour comparer au comportement du sable plastique qu’on a utilisé y a deux semaines et avec le même débit on a réussi à avoir assez rapidement un réseau en tresse et un petit méandre !

Pour voir les granulométries et lesquelles seraient préférentiellement emportées par le courant on pensait tamiser le sable et colorer les différentes granulométries qu’on aurait. Sauf que les sacs de sable à disposition étaient mouillés donc on en a séché une partie, ce qui a pris assez longtemps, pour au final se rendre compte que le sable était plus petit que la plus petite des granulométries de ‘sable plastique’.
Donc la prochaine fois on va devoir utiliser du sable plus grossier (et le tamiser) pour retrouver des granulométries équivalentes aux ‘sables plastiques’.
Autre réflexion : tout le sable était imbibé d’eau donc ça ressemblait plus à une plage qu’à un modèle analogique sur plusieurs km. Penser à la distance que représente la table dans la vraie vie et conséquemment changer les granulométries suivant si dans la vraie vie ça représente un grain de sable, un caillou, ou une roche.
Séance du 17/03
En terme de code : on a du recoder une des pièce d'entrée d'eau car les dimensions n'étaient pas bonnes et le code original a été effacé pour une raison inconnue.

Le code pour la partie de l'entrée d'eau fixée dans la planche :

fn = 90;rtube = 12.5;htube = 50;r1cone = 12.5;r2cone = 5.5;hcone = 10;transzcone = 30;hpetitcone = 8;r1petitcone = 5;r2petitcone = 5.5;transzpetitcone1 = 38;transzpetitcone2 = 46;transzpetitcone3 = 54;rvidetube = 10.5;hvidetube = htube + 1;transzvidetube = -0.99;r1videcone = 10.5;r2videcone = 3.5;hvidecone = hcone + 1;transzvidecone = 28.5;rvidepetitcone = 4;hvidepetitcone = 3*hpetitcone+1.1;transzvidepetitcone = 46;transxcle = 12.5;transzcle = -21.5;hcle = 3;rcle = 2;
difference(){    union(){        cylinder(htube, rtube, rtube, true, $fn = fn);        translate([0, 0, transzcone]) cylinder(hcone, r1cone, r2cone, true, $fn = fn);        translate([0, 0, transzpetitcone1]) cylinder(hpetitcone, r2petitcone, r1petitcone, true, $fn = fn);         translate([0, 0, transzpetitcone2]) cylinder(hpetitcone, r2petitcone, r1petitcone, true, $fn = fn);         translate([0, 0, transzpetitcone3]) cylinder(hpetitcone, r2petitcone, r1petitcone, true, $fn = fn);        translate([transxcle, 0, transzcle]) cylinder(hcle, rcle, rcle, true, $fn = fn);    }    translate([0, 0, transzvidetube]) cylinder(hvidetube, rvidetube, rvidetube, true, $fn = fn);    translate([0, 0, transzvidecone]) cylinder(hcone, r1cone, r2cone, true, $fn = fn);    translate([0, 0, transzvidepetitcone]) cylinder(hvidepetitcone, rvidepetitcone, rvidepetitcone, true, $fn = fn);}

Pour contrôler plus facilement l'arrivée d'eau et ne pas avoir autant d'élan à l'entrée du bac nous avons décidé de tenter de coder une Energy Dissipator Unit (EDU).
Code pour l'EDU

fn = 36;htubeext = 50;rtubeext = 25;htubeint = 35;rtubeint = 15;hbase = 2;transzbase = -2;rbase = rtubeext;hvidetubeext = 51;rvidetubeext = 23;transzvidetubeext = -0.5;hvidetubeint = 36;rvidetubeint = 13;transzvidetubeint = -0.5;rsphere = 3.5;transxsph = 14;transysph = 0;transzsph = 5;hcone = 24;r1cone = 0;r2cone = 15;transxcone = -25;transycone = 0;transzcone = 20;hcyl = 20;rcyl = 3;transxcyl = -24;transycyl = 0;transzcyl = 10;rsphext = 3;transzsphext = 10;
//basetranslate([0, 0, transzbase])cylinder(hbase, rbase, rbase, $fn = fn); 

 

//tubeintdifference(){cylinder(htubeint, rtubeint, rtubeint, $fn = fn);union(){translate([0, 0, transzvidetubeint]) cylinder(hvidetubeint, rvidetubeint, rvidetubeint, $fn = fn);translate([transxsph, transysph, transzsph]) sphere(rsphere, $fn = fn);    }}
//tubeextdifference(){cylinder(htubeext, rtubeext, rtubeext, $fn = fn);union(){translate([0, 0, transzvidetubeext]) cylinder(hvidetubeext, rvidetubeext, rvidetubeext, $fn = fn);translate([transxcone, transycone, transzcone])cylinder(hcone, r1cone, r2cone, $fn = fn);    translate([transxcyl, transycyl, transzcyl]) cylinder(hcyl, rcyl, rcyl);    translate([transxcyl, 0, transzsphext]) sphere(rsphext, $fn = fn);}}

A tester lors de la prochaine séance.
Pour la table
Loïc nous a expliqué que le phénomène qu'on observe avec le tri "inverse" de nos particules est l'effet granola, pas basé sur de la sédimentologie classique.  La loi de Stockes et les autres grands principes de sédimentologie s'appliquent quand il y a uniquement des interactions particule/fluide or ici on n'a que transport de fond pris en compte et non le transport par le fluide, d’où l'effet granola. Par ailleurs ici on est sur un modèle à grande échelle, et les petites particules passent au fond par transport de fond, conséquence des interactions entre particules.
On a un problème de ségrégation dans les flux granulaires selon la vitesse du courant et la taille particules. Cependant à la fin des expériences en faisant des coupes dans le delta on observe des laminations et du tri granulométries (couches alternes à la fin du méandre).
Par ailleurs il faut tester le débit et trouver une meilleure façon de le contrôler. Il faut le calculer à la sortie du tuyau et voir éventuellement pour un robinet.

Dans emriver, ils ont un EnergyDissipatorUnit à la sortie du robinet pour régler le débit : l'eau tombe dedans et sort en "inondation" (pas de  vitesse initiale = pas la petite mare sous le robinet) . Il faut comprendre le fonctionnement de cette pièce et la coder éventuellement. 

Débit pompe : 7sec pr 500mL en bloquant pas le tuyau : 71,4 mL/sec. En bloquant : 500mL en 34sec donc débit de 14,7mL/sec et ce sans la pièce de sortie d’eau. Besoin ré-imprimer pour tester avec la vraie pièce.

Nous nous sommes demandé aussi s'il ne faudrait pas "tricher" et diriger le départ de l'eau ?
Il faut aussi travailler à l'identification des paramètres responsables de la réussite de l'expérience pour sa reproductibilité.
On doit aussi trouver un pied pour mieux filmer.
 
Au final tout marche bien quand on tasse pas ! Beaux méandres et changements naturels en quelques minutes.
Nous avons remarqué la présence de fuites. 
Prochaines séances  : 
--> améliorer les prises de vue pour comparer chaque test, dire quel paramètre change, jour, date, échelle , … et toujours même angle

--> Potentiellement faire une Time lapse

--> Réfléchir aux proportions de couleurs etc

--> Coder edu

--> Qu’est-ce qu’on fait du sable mouillé ? Grand tamis pour égouter ? Comment sécher de telles quantités pour pas moississement, … laver le sable ? 
Séance du 24/03
D'un point de vue pédagogique, qu’est-ce que les étudiants vont voir ?
Qu’est-ce qu’ils vont mesurer ? On a besoin des distances pour faire des mesures et en photo : distorsion = besoin échelle pour corriger photos/vidéos, mais on peut aussi optimiser le placement de la caméra pour limiter la distorsion. 5 cm = 500m IRL
Il faut aussi faire une notice explicative, comme un tuto (avec toutes les étapes pour le poly des étudiants), avec des photos de comment et des instructions.
On doit donner les proportion optimales (poids de chaque quantité de sable mise).
Pour la pédagogie on pourrait faire un bac un peu plus long (120cm*65cm) pour que ça rentre sur une paillasse. Si il y a un besoin que ça soit plus long on peut augmenter la longueur et diminuer la largeur mais si on veut étudier aménagement territoire c’est plus intéressant que ça soit ce ratio (maison, barrage, …).
Pour la vis de sortie d'eau, il faudrait faire un filetage plus gros pour que ce soit plus facile à manipuler. Le but étant de soit pas toucher à vis pour pas modifier le débit et modéliser un système stationnaire ou augmenter le delta et là observer l’effet du changement niveau eau (régression, etc) pour un autre exercice (voir les mouvements du delta). Une autre expérience possible est d'ajouter de l’eau en bas pour mimer arrivée dans une mer/océan, verra-t'on une accelération du processus ?

Il faudrait calculer la hauteur de sable et d'eau optimale selon la pente pour voir des méandres. Par ailleurs, il ne faut pas dépasser 10mL/sec de débit pour la pente maximum.
On a remarqué qu'il fallait mouiller le sable au préalable pour éviter l'absorption de l'eau. Aussi, on a tenté de tracer un chemin initial pour guider le flux mais au final ça reste influencé par dynamique fluviatile !
Séance du 07/04/23
On a demander un devis pour avoir un bac en plexiglass mais le prix est trop élevé.
On a acheté une pompe réglable à plus faible débit (max 200L/h), tests pas concluants.
Séance 14/04/23
On a fait un test en trouvant un moyen d'avoir un débit stable avec la pompe de départ : mettre le tuyau dans un étau pour diminuer le débit (0,5cm d'écartement).
On a pesé la quantité de sable qu'il restait et on en a déduit qu'on a mis 10,61kg de sable dont tout le jaune à notre disposition (1,63kg), 6,65 de blanc, 1,55kg de noir et 0,78kg de rouge. Loic nos avait proposé de rajoutzr du blanc mais en comparant les proportions de chaque couleur on pense qu'il n'est pas recommander de rajouter du blanc vu que c'est celui qui part en 1er (on va rien voir après s'il y a que du blanc).
Tentative d'étanchéifier la table en bois avec du platique thermocollable. Impossible a faire avec un seul grand rectangle. On a donc coupé des petits rectangles (1 pour le fond et 4 pour les bords) à coller/souder entre eux aux niveau des angles et coins. On a pas eu le temps de finir mais ça a l'air pas trop mal.
Dernière séance 21/04/23
Le plastique thermocollable ça ne fonctionne pas c'est trop gondolé. On a aussi essayé de faire un pochoir pour que tout le monde ait les mêmes méandres mais ça tasse le sable.
On a tenté de faire une expérience juste avec du blanc et du noir.
1,6 kg de noir, sur 6,25 kg avant l’expérience. -> On a utilisé 4,65 kg, soit 74,4%.
1,9 kg de blanc, sur 9,6 kg avant l’expérience. -> On a utilisé 7,7 kg, soit 80,2%.
Donc on a utilisé 37,7% de noir et 62,3% de blanc.
Résultats en surface très faciles à visualiser même avec 2 couleurs.
En revanche, il est très difficile de distinguer l’enchaînement des phases de blanc/noir lorsqu’on fait une coupe dans le delta : il faudrait donc au moins 3 couleurs pour obtenir un signal plus satisfaisant.
Attention pour ça : ne pas utiliser du rouge, il reste en surface et n’apporte pas d’information intéressante.

Turbococco v.2


Informations

Tenue du wiki : Pablo Fava
Contact : pablo.fava@etu.sorbone-universite.fr
Etudes : Licence Troisième année Mécanique - Sciences de la Terre
Dates du Projet : du 4/02 au 31/04
encadrants : Loïc Labrousse et Pierre Thery
Dans le Cadre de l'ISTEP, dirigé par Fabrice Minoletti

Contexte
Mise en contexte : les coccolithophores sont de très bons indicateurs car ce sont des algues qui sont dans la zone de mélange pour pouvoir faire la photosynthèse, à l'inverse des foraminifères qui sont des organismes qui attendent majoritairement sous la zone de mélange. Les coccolithophores sont donc plus adaptés comme marqueur de la température passée.
Problème : leur taille de l'ordre du micromètre rend leur isolement par filtrage complexe.
Le protocole mis au point par Fabrice Minoletti et son équipe consiste donc à faire vibrer une micro membrane filtrante à l'aide d'une cuve à ultrasons. Le filtre étant très fin, l'opération s'étend sur des laps de temps conséquents. L'idée est donc d'automatiser le remplissage du cylindre et d'ajouter une agitation pour faciliter le filtrage.
Objectifs

- Transférer le montage précédent sur une Arduino nano 33ioT et créer une application dans le cloud arduino pour contrôler le montage à distance
- réaliser une série de tests pour déterminer l'efficacité de l'agitation de la solution et du filtrage
- faciliter la réplication du montage.

Représentation graphique du montage réalisée par Ismaël
Matériel

1 carte arduino nano 33ioT
deux capteurs de niveau d'eau
un moteur
un shield moteur
câbles arduino
bouchons et fixations et impression 3D
pompes

smartphone

Machines utilisées

imprimantes 3D
fer à souder
perceuse manuelle

Construction
(Fichiers, photos, code, explications, paramètres d'usinage, photos, captures d'écran...)
Ce que l'on a récupéré
Tout le montage fonctionne autour d'une carte Arduino. Grâce au groupe aillant travaillé sur le projet l'an dernier, la structure du modèle est déjà opérationnelle. La carte Arduino est reliée à 4 composants : une pompe, un moteur agitateur et deux capteurs de niveau. Le principe général est d'aider la filtration par la micro membrane et d'automatiser son remplissage.
Ainsi, deux concepts sont importants :

lorsque le capteur positionné en bas du tube ne détecte plus de solution, la pompe est activée pour un remplissage jusqu'à ce que le capteur haut détecte le niveau d'eau.
sur une boucle de 120 secondes, le moteur est activé pendant les 5 premières secondes afin de remettre les particules en suspension et désencombrer la membrane filtrante.

Comment on souhaite le transformer

Afin d'avoir davantage de possibilités, nous avons transféré le montage sur une carte Arduino 33ioT, qui aura pour plus tard la possibilité de communiquer avec Arduino Cloud et ainsi être pilotée à distance par un smartphone. Connectée à un Shield moteur, elle permet de ne pas avoir de pin board.

Journal de bord - Avancée du projet à chaque étape, difficultés rencontrées, modifications et adaptations
10/02/2023

On commence à transférer le projet de l'Arduino Uno vers la nano mais on se rend vite compte qu'on n'a pas la bonne Arduino nano, il nous faut la 33ioT.  Fabrice la commande pour la semaine suivante. ça nous bloque beaucoup parce qu'on ne peut pas commencer l'application non plus mais on est à peu près certain.e.s que tout fonctionne en-dehors de cela donc la session de la semaine suivante devrait être assez efficace.
17/02/2023
Ismaël a réussi à souder l'Arduino 33IOT et tout fonctionne. Seul problème : les capteurs ne détectent pas la présence d'eau. On essaie de serrer + les vis, sinon il faudra peut-être changer de capteur ou trouver une autre solution.
En attendant on doit modéliser la pièce manquante pour que l'hélice soit plus solide et voir si on a une tige de longueur suffisante pour passer sous le niveau du capteur bas.
On a réglé le problème en changeant les capteurs. Ils sont un peu moins réactifs mais ça ne gêne pas le fonctionnement global donc on les garde.
On a modélisé la pièce aux bonnes dimensions, mais on n'a pas de tige assez longue pour les nouveaux tubes du laboratoire. Pierre Théry va en commander à nouveau ou alors on peut en fabriquer une en tiges de métal mais on pense que ça ne sera pas assez rigide.

Photo du système total fonctionnel.
Léger problème d'étanchéité au bas du tube mais ça devrait se résoudre avec les tubes plus grands.
On a donc pu commencer à fouiller un peu pour créer l'application de contrôle à distance. On a établi les fonctionnalités nécessaires avec Fabrice :
- bouton démarrer le processus total
- bouton allumer et éteindre la pompe
- bouton allumer et éteindre le moteur agitateur
- bouton éteindre tout le système
il faut également refaire la soudure de la Arduino nano 33ioT

24/03/2023
Après une série de tests par Téa, résultats assez étranges, globalement la filtration est moins rapide avec agitation moteur. On a  rentré les résultats sur excel pour les analyser plus nettement :

Les temps les plus longs sont atteints lorsque le tube est agité par un moteur. Cela nous pose vraiment problème car le projet serait à moitié inefficace. On établit les sources d'erreurs potentielles :
- la position dans la cuve pourrait influer car il y a 3 sources d'ultrasons pour 4 emplacements
- le sens de rotation de l'hélice du moteur
On lance donc l'impression d'un bouchon avec emplacement moteur supplémentaire pour pouvoir faire plusieurs essais en parallèle et plus facilement identifier le problème.

31/03/2023
Problème avec les impressions de la semaine passée, on n'avait pas pris en compte la dilatation lors de l'impression donc le moteur ne rentre pas dans l'emplacement prévu.
On recommence l'impression aux bonnes dimensions
Entre temps, Téa a refait des tests avec une membrane plus petite et une nouvelle cuve. Cette fois-ci l'agitation moteur permet bien un filtrage nettement plus rapide. Cela rend donc caduque le besoin d'un nouveau bouchon avec emplacement moteur. Voilà les graphiques obtenus avec les données de Téa :

De plus, les lames au microscope sont beaucoup moins polluées de particules sans intérêt.
Nous n'avons pas eu le temps de réitérer suffisamment l'expérience et s'assurer que le résultat serait identique à chaque répétition. Cela peut être un bon axe de perfectionnement du système.

14/04/2023

Nouvel objectif : rendre tout le système pilotable à distance grâce au Arduino ioT Cloud
On transfère le code déjà créé pour la carte Arduino et on l'adapte aux exigences du cloud. Beaucoup de problèmes de compilations, utilisation de Chat GPt4 pour les résoudre.
Il reste quelques problèmes, on espère les résoudre avant l'oral :  le code compile mais les moteurs ne s'activent pas lors de l'activation des widgets sur l'application arduino

Codes Openscad

N.B : ajuster les dimensions pour prendre en compte la modification à l'impression

hélice agitation moteur

$fn=100;
nbPales=6;
rAxeRot=1.5;
rIntTub=32/2;
rTube=18;
//color("red")
//render()

translate([0,0,1]) {
 difference() {
 cylinder (h = 2, r=rIntTub, center=true);
 cylinder (h = 3, r=rIntTub-1, center=true);
 }
}
difference() {
 union (){
 linear_extrude(height = 10, twist = 10, slices = 60) {
 //circle(r=5);
 for(i = [0 : 1 : nbPales]) {
 rotate(a = i*360/nbPales) {
 square(size = [rIntTub, 1]);
 }
 }
 }
 cylinder (h = 15, r=4, center = false);
 }
 translate([0,0,7.5]){
 linear_extrude(height = 15, twist = 0, slices = 60){
 translate ([0,0,3.5]) {
 
 square(size = [5, 2],center=true);//rectangle 1
 rotate (a=90){
 square(size = [5, 2],center=true);
 }
 //cylinder (h = 30, r=rAxeRot);
 
 
}}}}
/*
 translate ([0,0,-1]) {
 cylinder (h = 30, r=rAxeRot);
 }
*/

tige complète

$fn=100;
nbPales=6;
rAxeRot=1.5;
rIntTub=32/2;
rTube=18;
//color("red")
//render()

translate([0,0,1]) {
 difference() {
 cylinder (h = 2, r=rIntTub, center=true);
 cylinder (h = 3, r=rIntTub-1, center=true);
 }
}
difference() {
 union (){
 linear_extrude(height = 10, twist = -10, slices = 60) {
 //circle(r=5);
 for(i = [0 : 1 : nbPales]) {
 rotate(a = i*360/nbPales) {
 square(size = [rIntTub, 1]);
 }
 }
 }
 cylinder (h = 147, r=3, center = false);
 
 }
 translate([0,0,140]){
 cylinder (h = 30, r=0.5);
 /*translate([0,0,7.5]){
 linear_extrude(height = 15, twist = 0, slices = 60){
 translate ([0,0,3.5]) {
 
 square(size = [3.8, 1],center=true);//rectangle 1
 rotate (a=90){
 square(size = [3.8, 1],center=true);*/
 }}
 
 //vincent mouchi claire lix
 

//NB : le trou pour connexion moteur était un peu trop faible, à agrandir

bouchon avec pas de vis et insert moteur

$fn=100;
hInt=20;
l=80;
diam=42.3;
/*
color("red")
translate ([-diam/2,-0.5,-hInt/2]) {
 cube([diam,1,20], center=false);
}
color("green")
render()
translate ([-l/2,-0.5,5]) {
 cube([l,1,4], center=false);
}
color("blue")
render()
difference () {
 difference () {
 cylinder (d=60, h=10);
 cylinder (d=45, h=10);
 }
 translate ([-l/2,3,-l/2]) {cube([l,l,l], center=false);}
 translate ([-l/2,-l-3,-l/2]) {cube([l,l,l], center=false);}
}
*/
translate ([0,0,-1]) {
 difference () {
 cylinder (d=50, h=3);
 translate ([0,0,-0.5]) {cylinder (d=3, h=5);}
 }
}
SVL42Cap ();
extend_mot();

difference(){
 
 cylinder(d=16,h=2,center=true);
 cylinder(d=3,h=2,center=true);}

module extend_mot (){//extension pour insertion moteur
 difference (){
 translate([0,0,-14])cylinder (d=50,h=14);
 translate([0,0,-14])cylinder(d=21,h=10);
 translate([0,0,-4]) cylinder(d=16,h=4);
 
 }
 
 }
 

/*difference () { // Pour observer une coupe
 SVL42Cap ();
 union () {
 translate ([-l/2,5,-l/2]) {cube([l,l,l], center=false);}
 translate ([-l/2,-l-5,-l/2]) {cube([l,l,l], center=false);}
 }
}*/

module SVL42Cap () {
 difference () {
 cylinder (d=50, h=hInt);
 moduleInt ();
 }
 difference () { // sommet du capuchon
 color("red")
 render()
 union () {
 cylinder (d=50, h=1.5);
 difference () {
 cylinder (d=50, h=1.5);
 cylinder (d=3, h=2);
 }
 } 
 
 //translate ([-15,2,-5]) {cylinder (d=1, h=10);}
 //translate ([-15,0,-5]) {cylinder (d=1, h=10);}
 //translate ([-15,-2,-5]) {cylinder (d=1, h=10);}
 }
}
module moduleInt () {
 translate ([0,0,hInt]) {
 difference () {
 cylinder (d=45, h=3, center=true);
 cylinder (d=37, h=4, center=true);
 }
 }
 metric_thread (diameter=diam+4, pitch=4, length=hInt, internal=true, thread_size=2, groove=true, angle=10, leadin=0);
 translate ([0,0,-0.5]) { cylinder (d=diam, h=hInt+1); }
}

/*module extension_moteur (){
 
 difference (){
cylinder (d=50,h=10, center=true);
cylinder(d=21,h=10, center=true);
 }

 difference(){
cylinder(d=50,h=4, center=true);
cylinder(d=16,h=4, center = true);}
 
 }*/
/*
metric_thread (diameter=8, pitch=1, length=4, internal=true);

diameter - outside diameter of threads in mm. Default: 8.
pitch - thread axial "travel" per turn in mm. Default: 1.
length - overall axial length of thread in mm. Default: 1.
internal - true = clearances for internal thread (e.g., a nut).
 false = clearances for external thread (e.g., a bolt).
 (Internal threads should be "cut out" from a solid using
 difference ()).
n_starts - Number of thread starts (e.g., DNA, a "double helix," has
 n_starts=2). See wikipedia Screw_thread.
thread_size - (non-standard) axial width of a single thread "V" - independent
 of pitch. Default: same as pitch.
groove - (non-standard) subtract inverted "V" from cylinder (rather than
 add protruding "V" to cylinder).
square - Square threads (per
 https://en.wikipedia.org/wiki/Square_thread_form).
rectangle - (non-standard) "Rectangular" thread - ratio depth/(axial) width
 Default: 1 (square).
angle - (non-standard) angle (deg) of thread side from perpendicular to
 axis (default = standard = 30 degrees).
taper - diameter change per length (National Pipe Thread/ANSI B1.20.1
 is 1" diameter per 16" length). Taper decreases from 'diameter'
 as z increases.
leadin - 0 (default): no chamfer; 1: chamfer (45 degree) at max-z end;
 2: chamfer at both ends, 3: chamfer at z=0 end.
leadfac - scale of leadin chamfer (default: 1.0 = 1/2 thread).
*/

/*
 * ISO-standard metric threads, following this specification:
 * http://en.wikipedia.org/wiki/ISO_metric_screw_thread
 *
 * Copyright 2017 Dan Kirshner - dan_kirshner@yahoo.com
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * See <http://www.gnu.org/licenses/>.
 *
 * Version 2.3. 2017-08-31 Default for leadin: 0 (best for internal threads).
 * Version 2.2. 2017-01-01 Correction for angle; leadfac option. (Thanks to
 * Andrew Allen <a2intl@gmail.com>.)
 * Version 2.1. 2016-12-04 Chamfer bottom end (low-z); leadin option.
 * Version 2.0. 2016-11-05 Backwards compatibility (earlier OpenSCAD) fixes.
 * Version 1.9. 2016-07-03 Option: tapered.
 * Version 1.8. 2016-01-08 Option: (non-standard) angle.
 * Version 1.7. 2015-11-28 Larger x-increment - for small-diameters.
 * Version 1.6. 2015-09-01 Options: square threads, rectangular threads.
 * Version 1.5. 2015-06-12 Options: thread_size, groove.
 * Version 1.4. 2014-10-17 Use "faces" instead of "triangles" for polyhedron
 * Version 1.3. 2013-12-01 Correct loop over turns -- don't have early cut-off
 * Version 1.2. 2012-09-09 Use discrete polyhedra rather than linear_extrude ()
 * Version 1.1. 2012-09-07 Corrected to right-hand threads!
 */

// Examples.
//
// Standard M8 x 1.
// metric_thread (diameter=8, pitch=1, length=4);

// Square thread.
// metric_thread (diameter=8, pitch=1, length=4, square=true);

// Non-standard: long pitch, same thread size.
//metric_thread (diameter=8, pitch=4, length=4, thread_size=1, groove=true);

// Non-standard: 20 mm diameter, long pitch, square "trough" width 3 mm,
// depth 1 mm.
//metric_thread (diameter=20, pitch=8, length=16, square=true, thread_size=6,
// groove=true, rectangle=0.333);

// English: 1/4 x 20.
//english_thread (diameter=1/4, threads_per_inch=20, length=1);

// Tapered. Example -- pipe size 3/4" -- per:
// http://www.engineeringtoolbox.com/npt-national-pipe-taper-threads-d_750.html
// english_thread (diameter=1.05, threads_per_inch=14, length=3/4, taper=1/16);

// Thread for mounting on Rohloff hub.
//difference () {
// cylinder (r=20, h=10, $fn=100);
//
// metric_thread (diameter=34, pitch=1, length=10, internal=true, n_starts=6);
//}

// ----------------------------------------------------------------------------
function segments (diameter) = min (50, ceil (diameter*6));

// ----------------------------------------------------------------------------
// diameter - outside diameter of threads in mm. Default: 8.
// pitch - thread axial "travel" per turn in mm. Default: 1.
// length - overall axial length of thread in mm. Default: 1.
// internal - true = clearances for internal thread (e.g., a nut).
// false = clearances for external thread (e.g., a bolt).
// (Internal threads should be "cut out" from a solid using
// difference ()).
// n_starts - Number of thread starts (e.g., DNA, a "double helix," has
// n_starts=2). See wikipedia Screw_thread.
// thread_size - (non-standard) axial width of a single thread "V" - independent
// of pitch. Default: same as pitch.
// groove - (non-standard) subtract inverted "V" from cylinder (rather than
// add protruding "V" to cylinder).
// square - Square threads (per
// https://en.wikipedia.org/wiki/Square_thread_form).
// rectangle - (non-standard) "Rectangular" thread - ratio depth/(axial) width
// Default: 1 (square).
// angle - (non-standard) angle (deg) of thread side from perpendicular to
// axis (default = standard = 30 degrees).
// taper - diameter change per length (National Pipe Thread/ANSI B1.20.1
// is 1" diameter per 16" length). Taper decreases from 'diameter'
// as z increases.
// leadin - 0 (default): no chamfer; 1: chamfer (45 degree) at max-z end;
// 2: chamfer at both ends, 3: chamfer at z=0 end.
// leadfac - scale of leadin chamfer (default: 1.0 = 1/2 thread).
module metric_thread (diameter=8, pitch=1, length=1, internal=false, n_starts=1,
 thread_size=-1, groove=false, square=false, rectangle=0,
 angle=30, taper=0, leadin=0, leadfac=1.0)
{
 // thread_size: size of thread "V" different than travel per turn (pitch).
 // Default: same as pitch.
 local_thread_size = thread_size == -1 ? pitch : thread_size;
 local_rectangle = rectangle ? rectangle : 1;

 n_segments = segments (diameter);
 h = (square || rectangle) ? local_thread_size*local_rectangle/2 : local_thread_size / (2 * tan(angle));

 h_fac1 = (square || rectangle) ? 0.90 : 0.625;

 // External thread includes additional relief.
 h_fac2 = (square || rectangle) ? 0.95 : 5.3/8;

 tapered_diameter = diameter - length*taper;

 difference () {
 union () {
 if (! groove) {
 metric_thread_turns (diameter, pitch, length, internal, n_starts,
 local_thread_size, groove, square, rectangle, angle,
 taper);
 }

 difference () {

 // Solid center, including Dmin truncation.
 if (groove) {
 cylinder (r1=diameter/2, r2=tapered_diameter/2,
 h=length, $fn=n_segments);
 } else if (internal) {
 cylinder (r1=diameter/2 - h*h_fac1, r2=tapered_diameter/2 - h*h_fac1,
 h=length, $fn=n_segments);
 } else {

 // External thread.
 cylinder (r1=diameter/2 - h*h_fac2, r2=tapered_diameter/2 - h*h_fac2,
 h=length, $fn=n_segments);
 }

 if (groove) {
 metric_thread_turns (diameter, pitch, length, internal, n_starts,
 local_thread_size, groove, square, rectangle,
 angle, taper);
 }
 }
 }

 // chamfer z=0 end if leadin is 2 or 3
 if (leadin == 2 || leadin == 3) {
 difference () {
 cylinder (r=diameter/2 + 1, h=h*h_fac1*leadfac, $fn=n_segments);

 cylinder (r2=diameter/2, r1=diameter/2 - h*h_fac1*leadfac, h=h*h_fac1*leadfac,
 $fn=n_segments);
 }
 }

 // chamfer z-max end if leadin is 1 or 2.
 if (leadin == 1 || leadin == 2) {
 translate ([0, 0, length + 0.05 - h*h_fac1*leadfac]) {
 difference () {
 cylinder (r=diameter/2 + 1, h=h*h_fac1*leadfac, $fn=n_segments);
 cylinder (r1=tapered_diameter/2, r2=tapered_diameter/2 - h*h_fac1*leadfac, h=h*h_fac1*leadfac,
 $fn=n_segments);
 }
 }
 }
 }
}
// ----------------------------------------------------------------------------
module metric_thread_turns (diameter, pitch, length, internal, n_starts,
 thread_size, groove, square, rectangle, angle,
 taper)
{
 // Number of turns needed.
 n_turns = floor (length/pitch);

 intersection () {

 // Start one below z = 0. Gives an extra turn at each end.
 for (i=[-1*n_starts : n_turns+1]) {
 translate ([0, 0, i*pitch]) {
 metric_thread_turn (diameter, pitch, internal, n_starts,
 thread_size, groove, square, rectangle, angle,
 taper, i*pitch);
 }
 }

 // Cut to length.
 translate ([0, 0, length/2]) {
 cube ([diameter*3, diameter*3, length], center=true);
 }
 }
}

// ----------------------------------------------------------------------------
module metric_thread_turn (diameter, pitch, internal, n_starts, thread_size,
 groove, square, rectangle, angle, taper, z)
{
 n_segments = segments (diameter);
 fraction_circle = 1.0/n_segments;
 for (i=[0 : n_segments-1]) {
 rotate ([0, 0, i*360*fraction_circle]) {
 translate ([0, 0, i*n_starts*pitch*fraction_circle]) {
 //current_diameter = diameter - taper*(z + i*n_starts*pitch*fraction_circle);
 thread_polyhedron ((diameter - taper*(z + i*n_starts*pitch*fraction_circle))/2,
 pitch, internal, n_starts, thread_size, groove,
 square, rectangle, angle);
 }
 }
 }
}

// ----------------------------------------------------------------------------
module thread_polyhedron (radius, pitch, internal, n_starts, thread_size,
 groove, square, rectangle, angle)
{
 n_segments = segments (radius*2);
 fraction_circle = 1.0/n_segments;

 local_rectangle = rectangle ? rectangle : 1;

 h = (square || rectangle) ? thread_size*local_rectangle/2 : thread_size / (2 * tan(angle));
 outer_r = radius + (internal ? h/20 : 0); // Adds internal relief.
 //echo (str ("outer_r: ", outer_r));

 // A little extra on square thread -- make sure overlaps cylinder.
 h_fac1 = (square || rectangle) ? 1.1 : 0.875;
 inner_r = radius - h*h_fac1; // Does NOT do Dmin_truncation - do later with
 // cylinder.

 translate_y = groove ? outer_r + inner_r : 0;
 reflect_x = groove ? 1 : 0;

 // Make these just slightly bigger (keep in proportion) so polyhedra will
 // overlap.
 x_incr_outer = (! groove ? outer_r : inner_r) * fraction_circle * 2 * PI * 1.02;
 x_incr_inner = (! groove ? inner_r : outer_r) * fraction_circle * 2 * PI * 1.02;
 z_incr = n_starts * pitch * fraction_circle * 1.005;

 /*
 (angles x0 and x3 inner are actually 60 deg)

 /\ (x2_inner, z2_inner) [2]
 / \
 (x3_inner, z3_inner) / \
 [3] \ \
 |\ \ (x2_outer, z2_outer) [6]
 | \ /
 | \ /|
 z |[7]\/ / (x1_outer, z1_outer) [5]
 | | | /
 | x | |/
 | / | / (x0_outer, z0_outer) [4]
 | / | / (behind: (x1_inner, z1_inner) [1]
 |/ | /
 y________| |/
 (r) / (x0_inner, z0_inner) [0]

 */

 x1_outer = outer_r * fraction_circle * 2 * PI;

 z0_outer = (outer_r - inner_r) * tan(angle);
 //echo (str ("z0_outer: ", z0_outer));

 //polygon ([[inner_r, 0], [outer_r, z0_outer],
 // [outer_r, 0.5*pitch], [inner_r, 0.5*pitch]]);
 z1_outer = z0_outer + z_incr;

 // Give internal square threads some clearance in the z direction, too.
 bottom = internal ? 0.235 : 0.25;
 top = internal ? 0.765 : 0.75;

 translate ([0, translate_y, 0]) {
 mirror ([reflect_x, 0, 0]) {

 if (square || rectangle) {

 // Rule for face ordering: look at polyhedron from outside: points must
 // be in clockwise order.
 polyhedron (
 points = [
 [-x_incr_inner/2, -inner_r, bottom*thread_size], // [0]
 [x_incr_inner/2, -inner_r, bottom*thread_size + z_incr], // [1]
 [x_incr_inner/2, -inner_r, top*thread_size + z_incr], // [2]
 [-x_incr_inner/2, -inner_r, top*thread_size], // [3]

 [-x_incr_outer/2, -outer_r, bottom*thread_size], // [4]
 [x_incr_outer/2, -outer_r, bottom*thread_size + z_incr], // [5]
 [x_incr_outer/2, -outer_r, top*thread_size + z_incr], // [6]
 [-x_incr_outer/2, -outer_r, top*thread_size] // [7]
 ],

 faces = [
 [0, 3, 7, 4], // This-side trapezoid

 [1, 5, 6, 2], // Back-side trapezoid

 [0, 1, 2, 3], // Inner rectangle

 [4, 7, 6, 5], // Outer rectangle

 // These are not planar, so do with separate triangles.
 [7, 2, 6], // Upper rectangle, bottom
 [7, 3, 2], // Upper rectangle, top

 [0, 5, 1], // Lower rectangle, bottom
 [0, 4, 5] // Lower rectangle, top
 ]
 );
 } else {

 // Rule for face ordering: look at polyhedron from outside: points must
 // be in clockwise order.
 polyhedron (
 points = [
 [-x_incr_inner/2, -inner_r, 0], // [0]
 [x_incr_inner/2, -inner_r, z_incr], // [1]
 [x_incr_inner/2, -inner_r, thread_size + z_incr], // [2]
 [-x_incr_inner/2, -inner_r, thread_size], // [3]

 [-x_incr_outer/2, -outer_r, z0_outer], // [4]
 [x_incr_outer/2, -outer_r, z0_outer + z_incr], // [5]
 [x_incr_outer/2, -outer_r, thread_size - z0_outer + z_incr], // [6]
 [-x_incr_outer/2, -outer_r, thread_size - z0_outer] // [7]
 ],

 faces = [
 [0, 3, 7, 4], // This-side trapezoid

 [1, 5, 6, 2], // Back-side trapezoid

 [0, 1, 2, 3], // Inner rectangle

 [4, 7, 6, 5], // Outer rectangle

 // These are not planar, so do with separate triangles.
 [7, 2, 6], // Upper rectangle, bottom
 [7, 3, 2], // Upper rectangle, top

 [0, 5, 1], // Lower rectangle, bottom
 [0, 4, 5] // Lower rectangle, top
 ]
 );
 }
 }
 }
}

Code Arduino nano par Ismaël

#include <ArduinoMotorCarrier.h>
 const unsigned long equivalence_ms_s=1000; // constante pour la convertion des ms en s
 unsigned long heure_start_ms, heure_start_sec; // variables pour stocker l'heure du début en ms et s
 unsigned long heure_delay_ms, heure_delay_sec; // variables pour stocker l'heure du retard en ms et s

 void setup() {
 Serial.begin(9600); // initialisation de la communication série à 9600 bites par s
 
 //Establishing the communication with the motor shield
 if (controller.begin())
 {
 Serial.print("MKR Motor Shield connected, firmware version ");
 Serial.println(controller.getFWVersion());
 }
 else
 {
 Serial.println("Couldn't connect! Is the red led blinking? You may need to update the firmware with FWUpdater sketch");
 while (1);
 }

 // Reboot the motor controller; brings every value back to default
 Serial.println("reboot");
 controller.reboot();
 delay(500); 
 M1.setDuty(0); 
 M2.setDuty(0); 
 }
 int remplissage=1; // variable "remplissage" qui vaut 1 par défaut
 int chrono = 0; // variable "chrono" qui vaut 0 par défaut
 
 void loop() {
 
 int sensorValue0 = analogRead(A7); // lit la valeur analogique reçue en A0, envoyée par le capteur BAS
 int sensorValue1 = analogRead(A2); // lit la valeur analogique reçue en A2, envoyée par le capteur HAUT

 //Serial.println(sensorValue1);
 Serial.println(sensorValue0); 
 
 float voltage0 = sensorValue0 * (5.0 / 1023.0); // conversion de la valeur analogique (de 0 à 1023) en voltage (de 0 à 5V) - capteur BAS
 float voltage1 = sensorValue1 * (5.0 / 1023.0); // conversion de la valeur analogique (de 0 à 1023) en voltage (de 0 à 5V) - capteur HAUT

 //Serial.println(voltage0);
 //Serial.println(voltage1); |||||||||

 if (remplissage == 1) { // si le niveau d'eau est sous le capteur du HAUT, alors : 
 if ((voltage0< 2.5) & (voltage1 < 2.5)) { // si le capteur BAS ne détecte pas l'eau, alors : 
 M1.setDuty(20); //On fait tourner le moteur à 20% 
 M2.setDuty(100); // On fait tourner la pompe à fond
 remplissage = 1; // on reste dans cette boucle
 } 
 
 if ((voltage0> 2.5) & (voltage1 < 2.5)) { // si le capteur BAS ne détecte pas l'eau, alors : 
 M1.setDuty(20); // On fait tourner le moteur à 20% 
 M2.setDuty(100); // On fait tourner la pompe à fond
 } 
 
 if ((voltage1 > 2.5)&(voltage0>2.5)){ // si le capteur HAUT détecte l'eau, alors :
 M1.setDuty(0); // On coupe le moteur
 M2.setDuty(0); // On coupe la pompe
 remplissage=0; // on entre dans la boucle suivante
 heure_start_ms = millis(); // dès que le capteur HAUT détecte l'eau, lecture de l'heure du début en ms
 heure_start_sec = (heure_start_ms/equivalence_ms_s);
 chrono = 0; // conversion des ms en s
 }
 }
 
 if (remplissage == 0) { // si le niveau d'eau est au dessus le capteur HAUT, alors : 
 if (voltage0 > 2.5) { // si le niveau d'eau est au dessus le capteur BAS, alors 
 if (chrono <= 5) { // si le chrono est < 5 s, alors : 
 M1.setDuty(20); // "pas de courant" en sortie 2 : le circuit est fermé dans la carte relais, le moteur fonctionne
 M2.setDuty(0);
 heure_delay_ms = millis(); // lecture du retard en ms
 heure_delay_sec = (heure_delay_ms/equivalence_ms_s); // conversion des ms en s
 chrono = heure_delay_sec - heure_start_sec; // calcul du chrono = (heure du début - heure du retard)
 remplissage = 0;
 }
 
 if ((chrono <= 60) & (chrono > 5)) {// si le chrono est > 5 s, alors : 
 M1.setDuty(0); // On eteint le moteur
 M2.setDuty(0); // On eteint la pompe
 heure_delay_ms = millis(); // lecture de l'heure du retard en ms
 heure_delay_sec = (heure_delay_ms/equivalence_ms_s); // conversion des ms en s
 chrono = heure_delay_sec - heure_start_sec; // calcul du chrono = (heure du début - heure du retard)
 remplissage = 0;
 }
 
 if (chrono > 60) { // si le chrono > 10 s, alors :
 chrono = 0; // le chrono est remis à 0 
 heure_start_ms = millis(); // l'heure du début est remis à jour en ms
 heure_start_sec = (heure_start_ms/equivalence_ms_s); // conversion des ms en s
 remplissage = 0;
 }
 }
 
 if (voltage0 < 2.5) { 
 remplissage = 1;
 }
 }
 //Serial.println(remplissage); ||||||||||||||||||
 } // ferme void loop 

Remerciements
Un grand merci à Fabrice Minoletti de nous avoir accueillis dans son laboratoire et de nous avoir fait confiance pour la réalisation de son projet. Merci à Loïc Labrousse pour sa disponibilité et à Pierre Thery pour son soutien en toute situation. Merci enfin et évidemment à Ismaël et Téa de constituer cette équipe efficace avec qui il a fait bon de travailler.Modèles Cristallins

Modélisation des systèmes cristallins
Comment rendre la compréhension de leurs éléments de symétries plus visuels ?

Camille Labbey et Alexandre Dubois
Encadrants : LoÏc Labrousse, Pierre Thery, Mathieu Chassé
Sommaire

I- Introduction II- Objectif du projetIII- Journal de bordIV- Projet et résultats finaux     a. Systèmes cristallins classiques     b. Systèmes cristallins avec éléments de symétries     c. Fichiers stl des modèles avec éléments de symétries     d. Fichiers stl des modèles classiques     e. Fichiers des patrons pour la découpeuse vinyle     f. Code complet OpenscadV- Annexe : Logiciels et machines utilisées                                                                                                                                                VI- BibliographieVII- Remerciements

I- Introduction

A l'échelle microscopique, les atomes sont ordonnés de façon précise et périodique dans les solides.  La plus petite entité permettant de décrire un solide est appelée maille. Il en existe sept : triclinique, monoclinique, orthorhombique, hexagonal, rhomboédrique, quadratique et cubique. Ce sont des hexaèdres. Toutes les mailles sont caractérisées par trois longueurs d'arêtes et les trois angles les séparant.
Dans cette UE, notre but est de réaliser des reproductions des mailles pour que les étudiants puissent mieux les visualiser et s'entrainer à voir et à trouver les éléments de symétries. En effet, ce sont ces éléments qui régissent les propriétés macroscopiques. Il en existe de plusieurs sortes : axes, plans miroirs et translations. Ici, nous ne nous intéressons qu'aux axes et aux plans miroirs.

Schéma d'une maille (quelconque)

II- Objectif du projet

Nous devons réaliser plusieurs sets de systèmes cristallins à but pédagogiques. Certains seront sans éléments de symétries et d'autres avec éléments de symétries. Ces modèles serviront dans le cadre d'un TP de cristallographie/minéralogie en licence de Sciences de la Terre. 

III- Journal de bord

Journal de bord
27/01/2023
Aujourd'hui, nous voyons avec le professeur ce qu'il souhaite pour le projet. Nous devons réaliser cinq sets d'entrainements et cinq sets de corrections. Pour cela , nous allons principalement utiliser l'impression 3D que ce soit avec de l'acide polyactique (PLA) ou de la résine. Les deux nécessitent des fichiers au format stl.
Nous sommes partis sur des modèles de 6cmx6cm. Nous avons commencé par visualiser avec Vesta certains minéraux pour découvrir leur structure. Nous avons alors remarqué que nous pouvions faire les fichiers stl à partir de Vesta.  Cependant, il n'était pas possible de faire les axes de symétries.
Dans un premier temps, nous allons recréer les mailles primitives à l'aide d'Openscad pour réaliser une base de données utilisable par les étudiants où ils pourront modifier les paramètres de mailles à leur guise. Une fois la base de donnée constituée, nous pourrons ajouter les éléments de symétries sur les mailles. Nous partirons sur des gravures pour représenter les éléments de symétries.

Pour la semaine prochaine, il serait bien que nous testions les impressions 3D et le flocage. C'est une technique qui nous permettrait de rajouter les éléments de symétries sur les polygones.

03/02/2023

Camille a réalisé un code pour que les élèves de M. Chassé puissent retrouver les systèmes cristallins. Ce code est censé marcher pour tous les systèmes. C'est à dire qu'en rentrant les paramètres a, b, c, alpha, bêta et gamma, le logiciel Openscad sera capable de recréer la maille voulue.

Pendant ce temps, Alexandre a imprimé les premiers modèles en PLA et a codé le système monoclinique avec ses éléments de symétries afin de savoir comment cela pourrait rendre (prise en main, poids, taille). Openscad a permis de fabriquer les fichiers stl mais il a fallu ensuite les rentrer dans IdeaMaker pour les rendre compatibles avec les imprimantes du Fablab, organiser le plateau, la qualité d'impression et éventuellement agrandir ou rétrécir les modèles.
Les imprimantes PLA se situent dans l'espace prototypage.
 Première impression en PLA : deux systèmes monocliniques
07/03/2023

Nous avons lancé les impressions des systèmes quadratiques, monocliniques et orthorhombiques avec des éléments de symétries. Il était compliqué, juste avec Openscad, de bien ajuster les tailles des axes ou des miroirs par rapport à celle de la maille. Cette impression était un test pour savoir à quel point les éléments doivent être gros.

08/02/2023

Lorsque les modèles à imprimer deviennent complexes, il est parfois nécessaire d'utiliser des supports pour stabiliser la structure et donner un sol sur lequel l'imprimante peut construire sa réalisation. Les impressions de la semaine dernière ont raté vraisemblablement à cause de la mauvaise gestion des supports. Soit ils n'y en avaient pas assez, soit ils étaient trop fins.
Echec de l'impression de quatre modèles : deux quadratiques et deux orthorhombiques
Seuls les monocliniques ont été épargnés. Cependant les axes sont minuscules, ce qui les rend extrêmement fragiles et les miroirs font brouillons. De plus, il y a une erreur dans le codage de ces monocliniques. En effet, ils n'ont pas été définis à partir des paramètres a, b, c, alpha, bêta et gamma mais à partir de coordonnées dont certaines erronées.

Premières impressions avec axes de symétries

10/02/2023
Nous avons relancé des impressions PLA des systèmes monoclinique (avec les bonnes dimensions cette fois-ci), quadratique et orthorhombique. Nous avons allongé et grossi les axes. Sur les impressions ci-dessous, plusieurs choses peuvent être remarquées. Déjà, le monoclinique est un test de représentation inversée. Au lieu de faire ressortir les axes, nous les avons creusés et au lieu de graver le miroir, nous l'avons fait ressortir. Cette visualisation ne sera pas gardée.

Ensuite, pour les deux autres modèles, la forme des axes varie. En effet, celle-ci est codifiée et correspond à la valeur de l'axe. S'il permet de faire 2 rotations, il sera ovale, un triangle, 4 un carré et 6 un hexagone. Enfin, il manque quelques plans miroirs sur le quadratique.

Rendez-vous et bilan de l'avancée du projet

Nous nous sommes alors entretenus avec M. Chassé. La taille de ces modèles lui convenait. En outre, nous pouvions voir sur le monoclinique les traces d'un marqueur pour tableau qu'il a effectué. Notre professeur souhaitait que ses étudiants puissent dessiner sur les futurs modèles d'entrainements puis effacer. Pour cette raison, les impressions finales d'entrainements seront blanches pour mieux voir l'encre. Par ailleurs, les premières impressions ont été conçues en exagérant les proportions de manière à être le plus explicite possible. Elles ne sont pas, pour cette raison, représentatives de la réalité. M. Chassé nous a demandé de caler les paramètres des modèles sur les dimensions de certains minéraux existant pour éviter les erreurs de représentation et de proportion. Il nous a précisé ensuite de faire attention à la longueur des axes. M. Labrousse a approuvé cette idée en ajoutant que des axes longs seraient fragiles.

A présent, il existe deux versions des programmes Openscad pour les étudiants afin qu'ils puissent visualiser les modèles en ligne.

Programme n°1 :

Programme n°2 :

Nous repartons donc aujourd'hui avec beaucoup d'objectifs :

vérifier s'il est possible d'effacer le marqueur des impressions PLA comme résine,
tester l'éthanol pour savoir s'il endommage les impressions car ce solvant permet d'enlever les marqueurs,
faire des impressions résines,
essayer avec M. Théry la lisseuse, un instrument chauffant pour lisser nos productions,
regarder si avec la découpeuse vinyle, coller des stickers afin d'écrire sur les modèles est envisageable,
voir si nous pouvons, à l'aide de la découpeuse à eau, recouvrir nos productions de plexiglas,
terminer toutes les corrections. Actuellement, il nous manque les systèmes rhomboédrique, cubique et hexagonale.

Par ailleurs, il est envisagé, sous réserve que nous terminions rapidement, de reproduire des mailles de minéraux existants, de coder les modèles avec les motifs (atomes ou molécules) dedans.

12/02/2023
Les systèmes classiques sont tous terminés pour les modèles simples (voir Systèmes cristallins classiques) et une partie des modèles avec axes aussi. (voir Systèmes cristallins avec symétries). Nous avons testé la lisseuse. Elle a déformé notre modèle. A la place, M. Théry nous a proposé d'utiliser la découpeuse vinyle pour coller un papier Velleda sur nos impressions en PLA afin d'avoir les formes parfaites. Cela nécessiterait l'utilisation du logiciel Inkscape pour avoir le chemin vectoriel. Il faut juste vérifier les dimensions du film pour savoir s'il est compatible avec la découpeuse. Nous pourrions également tester de lisser la surface avec du sable chauffé puisque le fer chauffé déforme notre structure. Enfin, plusieurs personnes nous ont conseillés de faire un trou universel dans les modèles puis de laisser les étudiants trouver quels axes correspondent à quelles cavités. Mais nous n'avons pas gardé cette proposition pour plusieurs raisons. D'abord, souvent les axes s'entrecroisent au centre de la maille. Pour éviter qu'ils ne se gênent, il aurait fallu les raccourcir de façon précise. Mais le principal problème rencontré concerne le maintien des axes au sein de la structure. Nous aurions dû créer un système de clefs et de serrures pour éviter que les axes ne tombent en manipulant le modèle.

17/02/2023
Lorsqu'un minéral est trouvé dans la réalité, sa forme ne correspond pas forcément à sa maille primitive. Il a pu être découpé selon des plans bien précis. On parle alors de troncature. Ci-dessous, il s'agit de la réalisation de troncatures pour le système cubique.

Essai de troncature du système cubique (cubo-octaédre) :

Essai de troncature du système cubique avec symétries (cubo-octaédre):

Au sein de la faculté, les impressions résine dépendent du Fablab de biologie/chimie. Il a fallu se rendre au Fablab biologie à l'atrium pour demander des informations sur l'imprimante résine mais il était fermé. Camille est allée faire un tour au Fablab chimie pour savoir s'il était possible de lancer une impression résine du système cubique avec axes de symétries. Cependant, le responsable du Fablab de chimie, a expliqué que les impressions doivent être lancées le jeudi. La résine est un fluide qui se polymérise sous l'effet des UV. Il faut stopper manuellement la réaction pour éviter des dégâts sur les produits. Si les impressions étaient lancées les vendredis soirs, au retour du week-end, elles seraient abimées ainsi que le matériel.
Camille enverra un mail ce week-end à Simon Lanis afin de convenir d'une date. Egalement, il serait bien d'écrire sur des échantillons de résine afin de savoir si nous pouvons effacer le marqueur. Comme les BIC Velleda sont les plus compliqués à enlever, nous allons faire nos essais de dessins avec.

L'impression du système cubique en haute résolution avec une coque très fine et un remplissage de 15% a pu être lancée. Il s'agit de la première impression haute résolution effectuée. Si au toucher elles sont plus lisses et visuellement plus jolies, la durée d'impression est beaucoup plus longue. Nous pourrons ainsi disposer d'un aperçu du rendu "final" que pourrait donner les systèmes. En principe, l'impression devrait être terminée ce week-end.

En parallèle, nous nous sommes rendu compte que les programmes servant à recréer les mailles ne fonctionnaient pas pour le système rhomboédrique. En effet, en comparant la taille des diagonales des faces, elles étaient toutes différentes. Or, le rhomboèdre est composé de 6 losanges identiques. Il fallait donc recoder ce système complètement puis ajouter les axes dessus. Cela signifiait également un disfonctionnement des programmes les rendant inaptes à l'enseignement.  Il s'agissait du seul système nous faisant défaut.

Dans un second temps, il nous faudra résoudre les problèmes de surface des pièces, elles doivent être les plus lisses possibles pour éviter l'absorption de l'encre au sein des porosités. La résine pourrait être une solution. En effet, si le film Velleda ne tient pas ou bien s'il est abîmé par les étudiants, le projet ne sera pas viable sur le long terme.
Les axes de symétries sont définitivement trop fragiles. Au moindre choc, chute, transport dans une poche, ils se cassent. Il faut trouver un meilleur rapport entre longueur/épaisseur des axes pour les préserver au maximum. Des axes plus petits mais plus larges semblent être adaptés.

Dans un troisième temps, nous pourrions créer deux boites avec la découpeuse laser ou un autre appareil pour ranger proprement tous les systèmes.
24/02/2023

L'impression du cube a partiellement fonctionné. Les axes situés sur la face inférieure n'ont pas été correctement imprimés.  En outre, elle souffre aussi d'un défaut puisqu'elle n'est pas lisse. Cela est dû au socle trop épais, difficile à retirer. En temps normal, les structures supports partent relativement facilement. Cependant, ici, il a fallu utiliser un cutter à ultrasons pour les couper puis limer le surplus de matière de la face postérieure. Pour les prochains essais, il serait bien d'utiliser des supports plus conséquents et plus larges que la face du cube.  Le reste du modèle est parfaitement imprimé, la surface est beaucoup mieux aboutie que les autres modèles et les axes plus petits devraient mieux résister.
Résultat de l'impression avec la meilleure résolution :

 

Photos de la face ratée avant et après limage :

 

 
Cutter à Ultrasons :

 
Réalisation d'essais de traces aux marqueurs sur des échantillons en résine :
Lorsque nous recevons pour la première fois les échantillons en résine, il nous est apparu que certains marqueurs pouvaient être effacés. Les marqueurs bleus et verts semblent être adaptés à notre projet puisqu'effaçables même après une heure d'attente. Ainsi, l'utilisation de résine translucide semble être une des solutions répondant aux critères de M.Chassé.

Pour la semaine prochaine, nous devons continuer à chercher les axes et plans miroirs du système rhomboédrique. En effet, il n'est toujours pas codé de façon correcte.

Par ailleurs, la boîte de fin de projet pourrait être construite à la découpeuse laser. Des crans sur les côtés de celle-ci serviraient à l'assemblage de chacune de ses faces. Enfin, l'intérieur comporterait de la mousse afin de préserver les impressions.

10/03/2023
Le code du système rhomboédrique a enfin été trouvé. Depuis plusieurs semaines, nous étions bloqués sur son automatisation au sein d'Openscad. Pour des valeurs de paramètres conformes à la définition du rhomboèdre (a=b=c, alpha=bêta=gamma), les losanges obtenus différaient les uns des autres. Nous nous en sommes rendu compte grâce aux axes. Il était impossible de les baser sur nos paramètres. Il fallait tout le temps tâtonner au cas par cas là où pour les autres systèmes tout est automatique. Cela nous a pris 3 semaines pour comprendre comment définir les longueurs de ce polyèdre. Par ailleurs, comme ce système ne marchait pas dans les codes d'amusement des futurs étudiants à cause de la complexité des coordonnées, il est plus que probable que les codes ne marchent pas non plus pour le système triclinique. Il dispose de trop de translations interdépendantes les unes des autres pour être aussi simple à coder. Si nous disposons d'un peu de temps à la fin, il pourrait être intéressant de trouver comment le créer dans Openscad.

Après avoir testé plein de variantes différentes, c'est finalement via la résolution d'un système à deux inconnus que les translations ont été trouvées. C'est en effet le passage de la structure 2D en 3D qui posait problème. D'une part le triangle rectangle entre la translation en x, la longueur a (hypoténuse) et la hauteur mais également via les coordonnées du vecteur BE, et BD dont on a comparé les normes.

Schémas de la solution
//variable
a=6.36;
alpha=46.6;

//définition des translations

ralpha=alpha*3.14/180;
x=a*cos(alpha/2);
y=a*sin(alpha/2);
x1=(y)^2;
x2=(x)^2;
x3=2*x;
tx=(a^2-3*x1+x2)/x3;
tz=sqrt(a^2-tx^2);

//polyèdre
A=[0 ,0 ,0 ];
B=[x ,y ,0 ];
C=[2*x ,0 ,0 ];
D=[x ,-y ,0 ];
E=[tx ,0 ,tz ];
F=[tx+x ,y ,tz ];
G=[2*x+tx,0 , tz];
H=[tx+x ,-y , tz];
points=[
A,
B,
C,
D,
E,
F,
G,
H];
face=[[0,1,2,3],//sol
 [4,5,1,0],//au dessusi
 [7,6,5,4],//derrière
 [5,6,2,1],//droite
 [6,7,3,2],//gauche
 [7,4,0,3]];//devant

//vérification
polyhedron(points,face);
v1=B-E;// B et E
v2=H-F;// F et H
v3=A-F;
v4=A-C;
nv1=norm(v1);
nv2=norm(v2);
nv3=norm(v3);
nv4=norm(v4);
echo(nv1,"norme de v1");
echo(nv2,"norme de v2");
echo(nv3,"norme de v3");
echo(nv4,"norme de v4");
echo (tx,tz);
Code pour le rhomboèdre
Il est à noter que ce code marche également pour le cube si les angles sont égaux à 90°, c'est pour cela que dans la définition du rhomboèdre, les angles doivent être différents de 90°.

17/03/2023

Nous avons continué la pose des axes de symétries sur le rhomboèdre. En parallèle, trois nouveaux modèles en PLA  ont été imprimés afin de les recouvrir de papier film Velleda. La commande que nous avions passé, est arrivée la semaine dernière. Enfin, le cube a été projeté afin de tester sa résistance. Certains éléments de symétries ont été cassés. Leur durée de vie est donc le principal souci pour les modèles de corrections.
22/03/2023 :

Une impression résine a été lancée pour les systèmes suivants : - cubique classique - quadratique classique - orthorhombique classique- monocline classique - triclinique classique - hexagonal classique- cubique corrigé - quadratique corrigé- orthorhombique corrigé

Il était initialement prévu d'imprimer le rhomboédrique classique. Cependant, le fichier slt ne se chargeait pas sur le logiciel de visualisation Chitubox. L'utilisation de l'imprimante en résine est plus technique et plus coûteuse que celles utilisant le PLA. De plus, le bac doit être rempli de façon précise avant l'impression pour éviter d'être en manque de résine pendant la fabrication des modèles. Ici il fallait 62ml.
Les systèmes ont été fabriqués simultanément à l'aide d'une seule imprimante en résine grise. Ils font environ 2cm de long. C'est plus petit que les autres impressions mais cela a permis de tous les avoir rapidement. Nous pourrions les avoir en blancs, noirs ou transparents. Ce serait bien d'essayer ces couleurs afin de les comparer.
24/03/2023:

L'impression des modèles en résine a duré 2 heures. Elle n'a pas fonctionné pour les polygones dans la partie gauche du récipient contenant la résine. Néanmoins, la définition des objets est bien plus fine qu'avec l'impression à filament.
Ainsi les systèmes imprimés à ce jour sont : - système cubique classique - système cubique corrigé- système monoclinique classique - système orthorhombique corrigé - système hexagonal classique

Photos des premières impressions en résine
Etapes de traitement pour l'impression résine : - Enlever à l'aide d'une spatule en plastique les supports collés aux films,- Décrocher les systèmes des supports,- Transvaser le restant de résine dans le conteneur à résine à l'aide d'un filtre pour permettre de filtrer les morceaux,- Gratter à l'aide d'une spatule en plastique les morceaux solides encore accrochés aux films,- Nettoyer à l'aide d'un papier le bac,- Laver à l'aide d'un papier et d'un solvant (propanol) le bac de résine, - Plonger entre 5 et 15 minutes les pièces dans un grand volume de solvant afin d'enlever la résine liquide résiduelle,- Sortir les pièces du solvant et les laisser sécher sous la hotte,- Rincer à l'eau et au savon les spatules, l'entonnoir, le filtre et le support où étaient suspendues les impressions, - Exposer ces dernières aux ultraviolets naturels ou synthétiques pour durcir les pièces.
24/03/2023
Après avoir récupéré les impressions en résine, nous avons écrit dessus avec un feutre Velleda vert pour savoir si elles étaient effaçables. La réponse est "non". Pourtant au toucher, les surfaces paraissaient lisses. Avec M. Labrousse, nous avons regardé au microscope électronique le trait de Velleda sur le cube en résine. Grâce à celui-ci, nous avons vu des sillons droits apparaître au sein de la surface (grossissement x40). Elle est donc poreuse. L'encre reste dans les parties creuses du cube (grossissement x1000). Le microscope possède l'option topographie. Nous en avons donc profité pour réaliser la topographie de l'échantillon. Il n'était pas lisse à cause de sa porosité et possède un relief. Nous pourrions éventuellement tester l'acétone ou l'éthanol pour regarder si l'encre aurait pu disparaitre sans abîmer l'échantillon
En revanche, il semblerait que les impressions en résine sont plus résistantes que les impressions en PLA. Nous pourrions faire les modèles correctifs en résine afin de conserver les axes qui restent trop fragiles.

Grossissements du cube x40 et x1000

Topographie d'une surface du cube
L'image supérieure droite montre la coupe sur la surface du cube pour un grossissement x1000. Celle en haut à gauche présente une carte de la surface analysée en fonction de la hauteur. Le bleu vaut 0 micromètre et le rouge 18.  Enfin, la courbe en bas est la topographie de la surface pour un grossissement x1000.

Dans un second temps, après avoir reçu le film Velleda, nous avons pu tester la découpeuse vinyle afin de recouvrir les modèles d'exercices.                                                                                                                                                              

Les trois impressions en PLA noir de la semaine dernière ont été recouverts de papier Velleda. Sur le logiciel Graphtec Studio, il est possible soit de reproduire les faces des modèles soit de créer un patron. Ici, le cube est recouvert d'un patron exactement aux bonnes dimensions. Le patron du monoclinique est légèrement plus grand afin de prendre en compte les déformations dues au pliage. Le rhomboèdre est recouvert par 6 losanges.                                                                                                                        Les patrons semblent plus adaptés que le collage face par face. Notamment parce que l'une des faces du rhomboèdre  a été perdue. D'ailleurs, exagérer les proportions du patron n'est pas une bonne idée. En effet, les pliages sont disgracieux, il faut découper ce qui dépasse, ce qui n'est pas évident. Même le cutter à ultrasons n'est pas pratique pour cette besogne. Il fait fondre le film et légèrement le PLA.  Ces modèles résistent bien mieux aux chutes depuis un bureau ou plus haut. Par ailleurs, comme le film Velleda est conçu pour être utilisé avec des marqueurs, il n'y a aucun problème pour effacer les écritures. Cependant, le papier film Velleda se colle mal sur le PLA. L'usage de colle est obligatoire pour une utilisation pérenne des modèles.  Il semblerait que la Loctite 406 adhère mieux sur le plastique. Comme nous souhaitons réaliser 5 sets de 7 pièces, cela va prendre du temps de recouvrir l'intégralité de nos systèmes.  De plus, il existe déjà des modèles d'entrainements similaires. Ils sont beaucoup plus gros mais il n'y a qu'un seul set. Ici, plusieurs groupes pourront s'exercer simultanément.

Cette solution semble être la plus adaptée pour notre projet mais nous en discuterons avec M. Chassé lors de notre prochaine entrevue pour savoir si cela lui convient. Si tel est le cas, alors nous utiliserons du PLA blanc pour les modèles afin de masquer au maximum les imperfections de collage.

Photo des trois modèles recouverts de film Velleda, le cube a des arêtes de 3cm
31/03/2023
Aujourd'hui, nous avons rencontré M.Chassé pour faire le point sur l'avancée du projet. Après avoir discuté avec lui, nous avons décidé de faire les systèmes recouverts de Velleda pour les modèles d'exercices. A l'inverse, les modèles de corrections seront réalisés en résine. Nous espérons ainsi qu'ils seront plus résistants que les modèles en PLA.                                        

A cette fin, nous avons définis des dimensions précises basées sur celles de minéraux pour chaque système pour qu'ils soient facilement reproductibles en cas de perte, de casse ou de vol (fichiers stl et fichiers stl de correction). Pour éviter au maximum des soucis d'impressions, nous voulions utiliser deux imprimantes pour imprimer les 35 modèles (7*5). Cependant, une des imprimantes n'a pas marché donc il n'y en aura que la moitié pour le moment.            

Si nous parvenons à terminer rapidement, nous allons ensuite réaliser une boite afin de protéger des chocs, pertes mais également de préserver la colle.
08/04/2023
Nous avons eu un problème d'impression sur les 16 modèles lancés la semaines dernière. 7 ont été imprimés mais seulement 3 ou 4 sont exploitables, les autres ont trop de défauts pour être recouverts de film. De ce fait, les impressions seront lancées petit à petit les unes après les autres, ce qui nécessitera un temps considérable.                                                                    

La découpeuse vinyle aussi a été compliquée à utiliser. Il a fallu demander pour la réalisation des trois tests des semaines précédentes, l'ordinateur d'une personne ayant déjà réussi à la faire fonctionner. D'autre part, comme elle est précise au mm et les impressions à + ou - 0.4 mm, il faudra voir comment cela impacte le recouvrement des modèles.  Par ailleurs, la quantité de film nécessaire pour la bonne réalisation du projet semble plus conséquente que prévu.

En ce qui concerne la colle,  le cube et le rhomboèdre ont été enduits de cette dernière puis malmenés pendant 7 jours. Au terme de la semaine, aucun décollement n'était repérable.

12/04/2023
Les modèles d'entrainements sont tous soit en cours d'impression soit terminés. Il faudra juste les recouvrir. La découpeuse vinyle ne fonctionne pas. Le logiciel conçu pour communiquer entre la découpeuse et un ordinateur est Graphtec Studio. Cependant, il est impossible de faire communiquer un pc avec la découpeuse. Que ce soit celui d'Alexandre, les ordinateurs portables du Fablab ou bien la tour installée spécialement pour la découpeuse. Pourtant celle-ci fonctionne. Après avoir testé plusieurs logiciels, il semble compliqué d'identifier la source du problème. C'est embêtant puisque la découpeuse impacte directement le bon déroulement de notre projet.

14/04/2023
Une impression en résine a été réalisée jeudi pour les modèles cristallins avec axes et plans miroirs aux bonnes dimensions. De ce fait, leur volume est plus conséquent. En outre, les axes ont été épaissis et leurs longueurs raccourcies afin de limiter la casse sur le long terme. Malheureusement, nous avons minimisé le volume de résine nécessaire à l'impression. De ce fait, les modèles ont été partiellement imprimés. Pour pallier à cette erreur, un nouveau rendez-vous est fixé à la semaine prochaine.

Photo de l'échec d'impression en résine
La pose des éléments de symétries sur le système rhomboédrique est terminée. C'était le seul manquant.

D'autre part, tous les modèles d'exercices sont imprimés. Il y a au final 7 sets de 7 pièces.

Photo de toutes les impressions d'entrainements
Avec Pierre, nous avons discuté des différentes possibilités pour la fabrication de la boite, sous réserve que nous disposions de temps :

- boite en bois avec couvercle de plexiglass pour voir correctement les modèles,- mousse prédécoupée reprenant la forme des impressions, - noms des modèles gravés sur le plexiglass.
Enfin, comme la semaine dernière, la découpeuse vinyle refuse toujours de fonctionner. Nous allons devoir envisager de faire toutes les découpes à la main. Il va falloir remédier à ce problème au plus tard la semaine prochaine afin de commencer la pose du Velleda.

Suite à un nouveau rendez-vous au Fablab Chimie, les systèmes cristallins ont été imprimés en résine blanche. Contrairement au premier modèle, nous avons épaissi les axes et accentué les encoches des plans miroirs. Cependant, les modèles ne sont pas parfaits. En effet, on observe des modifications de l'état de surface. Les faces ne sont pas parfaitement tabulaire dus à différents facteurs. Tout d'abord, l'imprimante repose sur une table de laboratoire dans un endroit de passage. Ainsi, les vibrations suscitées par l'environnement ont pu être enregistrées sur certaines couches. De plus, les modèles étant denses (car ils sont pleins), il aurait fallu augmenter la densité des supports pour éviter un affaissement de la matière du à la gravité. Aussi, on peut remarquer des marques de supports à certains endroits des figures. Pour palier à ces imperfections, nous pourrions essayer d'imprimer les modèles sous une hôte qui a la particularité d'absorber les vibrations que subit l'imprimante. Ou sinon, placer l'imprimante sous un tapis de mousse pour limiter les secousses. Concernant les supports, il faudrait trouver le bon compromis entre des supports peu denses qui ne laisseraient aucune trace sur les modèles et des supports denses qui permettraient un meilleur maintien.
Les modèles ci-dessous ont été placés 2h après impression sur le rebord d'une fenêtre pour qu'ils continuent de se solidifier à l'UV. 

Modèles avec éléments de symétries imprimés à la résine
Visualisation des modèles cristallins sur Chitubox

19/05/2023

Comme les examens sont presque tous terminés, nous avons eu le temps de travailler sur le code permettant de recréer chacune des mailles.
En réalité, il s'agit du code de la maille triclinique. Comme c'est elle qui dispose du plus de liberté sur ses paramètres. La modéliser rend obsolète les autres code dont celui du rhomboèdre car nous pouvons tous les concevoir en ajoutant des contraintes sur la maille triclinique.

Cependant, ce code ne marche pas pour toutes les valeurs d'angles. La difficulté rencontrée pour recréer une maille provient des translations en x,y et z (tx,ty et tz) entre la face inférieure et la face supérieure. Openscad utilise huit sommets pour déduire les faces. En définissant 4 sommets pour la face inférieure et 4 pour la supérieure, cela revient à dupliquer la face inférieure avec une translation identique en x,y et z pour les 4 points supérieurs. Dans le code, comme A possède pour coordonnées (0,0,0), le point E à pour coordonnées les translations. Après avoir définit les trois équations pour les trois inconnus, il suffit de les résoudre. Cependant, tz  n'admet pas de solutions pour certaines valeurs. Si, dans le code (voir IV f.) , il vaut :

sqrt(c^2+a^2-2*a*c*cos(180-beta)-ty^2-(a+tx)^2)
La solution la plus simple de tz est :
tz= sqrt(c^2-ty^2-tx^2);
(Les deux expressions sont équivalentes et donnent le même résultat mais dans la recherche de la suppression de la racine pour tz, nous avons tenté de trouver d'autres solutions.)
Or ty et tx dépendent des angles bêta et alpha. Quand ceux-ci deviennent trop extrêmes (par exemple: 90;10;10) , le résultat de la soustraction devient négatif ce qui empêche la résolution de l'équation.

Pour pallier à ça, nous avons pensé à mettre en valeur absolue la racine mais cela créer une déformation de la maille. Comme les nombres complexes n'existent pas non plus sur Openscad, nous avons opté pour un message d'erreur quand la maille ne serait pas construisible.

IV- Projet et résultats finaux
Notre projet avait pour objectif de réaliser des sets pour les étudiants des années suivantes en minéralogie. Ainsi grâce à ces modèles cristallins, les étudiants pourront visualiser et manipuler les différentes mailles cristallines constituant la matière.

Même si les mailles sans axes existaient déjà, que ce soit en version physique ou bien sur les logiciels, celles réalisées dans ce projet seront plus adaptées puisqu'elles seront utilisables par plusieurs groupes dans une classe contrairement aux modèles existants qui n'étaient manipulables que par le professeur pour présenter à ses élèves les cristaux.

Notre travail s'est décomposé en deux parties. Tout d'abord, recréer avec Openscad les différentes mailles cristallines définies par des propriétés géométriques. Pour ce faire, nous avons défini un repère en 3D ayant comme axes les arêtes de longueurs a, b, c du polyèdre. Quant aux angles alpha, bêta et gamma, ils représentent respectivement les angles entre (b,c), (c,a) et (a,b). Les modèles cristallins sont tous des hexaèdres composés de six faces.

Nom de la maille
valeurs de la longueur des axes a,b et c
angles entre les axes a,b et c.

Triclinique
a≠b≠c
alpha≠bêta≠gamma

Monoclinique

a≠b≠c
alpha=gamma=90°≠bêta

Orthorhombique

a≠b≠c
alpha=bêta=gamma=90

Hexagonal
a=b≠c
alpha=bêta=90, gamma=120

Rhomboédrique
a=b=c
alpha=bêta=gamma≠90

Quadratique
a=b≠c
alpha=bêta=gamma=90

Cubique
a=b=c
alpha=bêta=gamma=90

Nous avons remplacé les valeurs des longueurs et des angles caractéristiques du tableau par les paramètres de mailles de vrais minéraux (voir fichiers stl). - Dimensions de la chlorite pour le monoclinique,- Dimensions de l'andalousite pour l'orthorhombique,- Dimensions du corindon pour l'hexagonal,- Dimensions de la calcite pour le rhomboédrique, - Dimensions de la braunite pour le quadratique,- Dimensions de la fluorite pour le cubique.
Dans un second temps, une fois les modèles originaux terminés, nous avons pu coder sur Openscad les éléments de symétries.
a- Systèmes cristallins classiques

Systèmes cristallins classiques sur Openscad
Système Cubique :

Système Orthorhombique :

Système Quadratique :

Système Rhomboédrique :

Système Hexagonal :

Système Monoclinique :

Système Triclinique :

b- Systèmes cristallins avec symétries
Pour chacun des systèmes cristallins : - Les axes A4 sont modélisés par les losanges,- Les axes A3 sont modélisés par les triangles,- Les axes A2 sont modélisés par des ellipsoïdes,- Les plans miroirs sont modélisés par des quadrilatères très fins sur chaque facette puis soustrait à la forme cubique initiale (fentes vertes sur la figure ci-dessous). 

Tous les systèmes possèdent des éléments de symétries sauf le système triclinique.

Systèmes cristallins avec symétries sur Openscad
Système Cubique :

Système Orthorhombique :

Système Quadratique

Système hexagonal

Système rhomboédrique :

Système monoclinique :

Système Triclinique :

Systèmes cristallins imprimés en résine blanche

c- Fichiers stl des modèles classiques

Ces fichiers sont au format stl correspondant au format conforme pour les impressions 3D en PLA et en résine. 

Fichiers stl des modèles classiques
cubique_dim_fluorite.stl
hexagonal_dim_corindon.stl
monoclinique_dim_chlorite.stl
orthorhombique_dim_andalousite.stl
quadratique_dim_braunite.stl
rhombo_dim_calcite_v2.stl
triclinique V2.stl

Fichiers Openscad des modèles redimensionnés
exercice_hexagonal_2_2_3.scad
exercice_monoclinique_2.5_3_3.5_70.scad
exercice_orthorombique_3,5_3_2,5.scad
exercice_quadratique_3_3_2,5.scad
exercice_triclinique_2.5_3_3.5_80_60_70.scad
exercice_cubique_3_3_3.scad
exercice_rhomboèdrique_3_60.scad

d- Fichiers stl des modèles avec symétries

Fichiers stl des modèles avec symétries
monoclinique_correction.stl
Symétrie_orthorhombique_correction .stl
tiers_d'hexagonal_correction.stl
hexagonal_correction.stl
Symétrie_quadratique_correction .stl
Symétrie_cubique_correction.stl
Rhombohédrique_correction.stl

e- Fichiers gstudio des patrons

Fichier découpeuse vinyle
rhomboèdrique + triclinique + quadratique + monoclinique qui marchent.gstudio
orthorombique.gstudio

cube.gstudio

hexagonale.gstudio

f-Code complet Openscad
Ce fichier permet de recréer toutes les mailles cristallines par rapport à leur paramètres. Il marche pour les systèmes cubique, quadratique, rhomboédrique, hexagonal, monoclinique et orthorhombique. Pour le système triclinique, il ne fonctionne pas pour toutes les valeurs d'angles.

//paramètres de la maille

a=10;
b=10;
c=10;

alpha=90;
gamma=30;
beta=70;

// coordonnées intermédiaires et translation

x=b*cos(gamma);
y=b*sin(gamma);

s=(2*b*c*cos(180-alpha)+x^2+y^2-b^2-2*a*c*cos(180-beta))/(2*(a-x));

ty=(x-a)*(s+c*cos(180-beta))/y;
tx=s+(y*ty)/(a-x);
tz=sqrt(c^2+a^2-2*a*c*cos(180-beta)-ty^2-(a+tx)^2);

//vérification de la structure

if (c^2+a^2-2*a*c*cos(180-beta)-ty^2-(a+tx)^2>0) {

// construction des points
A=[0,0,0];
B=[a,0,0];
D=[x,y,0];
C=[a+x,y,0];
E=[tx,ty,tz];
F=B+E;
G=C+E;
H=D+E;

//construction de la maille 

points=[
A,B,C,D,E,F,G,H];
face=[[0,1,2,3],//sol
 [4,5,1,0],//au dessusi
 [7,6,5,4],//derrière
 [5,6,2,1],//droite
 [6,7,3,2],//gauche
 [7,4,0,3]];//devant
polyhedron(points,face);

//vérification des valeurs

echo("y",y);
echo("x",x);
echo("s",s);
echo("tx",tx);
echo("ty",ty);
echo("tz",tz);
v1=B-E;// B et E
v2=H-F;// F et H
v3=A-F;
v4=A-C;
nv1=norm(v1);
nv2=norm(v2);
nv3=norm(v3);
nv4=norm(v4);
echo(nv1,"norme de v1");
echo(nv2,"norme de v2");
echo(nv3,"norme de v3");
echo(nv4,"norme de v4");
echo(c^2-ty^2-tx^2);
echo("E-H",norm(E-H));
echo("F-G",norm(F-G));
echo(tz==undef);
}
else 
 //si ça ne marche pas 
 color([1,0.8,0]){ linear_extrude(4){text("erreur",font="Comic Sans MS:style= Bold");}};

V- Annexe : Logiciels et machines utilisés

Logiciels et machines utilisés

Openscad
Il s'agit du logiciel sur lequel nous avons passé le plus de temps. Il permet de créer, visualiser et exporter au bon format les objets à imprimer. C'est à dire qu'il conçoit les fichiers stl pour les imprimantes 3D. Pour cela, il faut rentrer, sous forme de code les instructions. Il existe une page dans le mode d'emploi du logiciel avec des aides pour débutants "cheatsheet".
Openscad marche sous la forme d'un éditeur de code. Le langage utilisé est C++.Il permet aussi de faire des vrais programmes avec des boucles, des fonctions mathématiques, etc... mais nous n'avons pas eu besoin d'utiliser cet aspect du logiciel.

IdeaMaker
Il s'agit de l'un des deux logiciels d'adaptation des fichiers stl pour les imprimantes. Celui-ci est gratuit ainsi que développé par la société ayant fourni le Fablab prototypage. Il doit être utilisé pour les imprimantes en 3D PLA.

Lorsque le fichier stl est créé, il faut ensuite, le rendre compatible avec l'imprimante. Le logiciel connait les dimensions de celle-ci afin de ne pas dépasser de l'imprimante. Ensuite, il faut réarranger sur le plateau la disposition des modèles pour éviter les chevauchements notamment. Parfois l'ajout de support est nécessaire pour maintenir la pièce. Comme les imprimantes n'utilisent qu'un seul fil continu, il est important de veiller à toutes ses œuvres. Si l'une est ratée, l'erreur se propage partout.  Par défaut, les pièces sont imprimées sur un socle. En fonction de la solidité de celles-ci, de leur taille et de leur forme, il est possible d'adapter son socle. Ce logiciel permet aussi de redimensionner les impressions pour gagner du temps ou pour respecter les dimensions de l'imprimante. Enfin, il permet de choisir la qualité de son impression. En effet, en PLA, plusieurs qualités sont disponibles. Elles sont à choisir en fonction du temps disponible puisqu'elles n'agissent que sur le diamètre du fil utilisé. Une meilleure impression aura un film plus petit. Cela peut également jouer sur le remplissage de la pièce afin de la rendre plus lourde ou plus solide.

Impression 3D en PLA
Les imprimantes ayant servi à créer les modèles d'entrainements sont des imprimantes Raise3D Pro 2 (FDM). Elles fonctionnent avec le dépôt d'un filament, de l'acide polylactique pour nous.

Une fois le modèle créé avec Openscad et adapté à l'aide d'IdeaMaker, l'imprimante peut faire son œuvre.
Afin d'augmenter les chances de réussir l'impression, il est vivement conseillé de surveiller le début d'impression de l'objet souhaité. Le PLA est disponible en plusieurs couleurs, et si le projet l'avait nécessité, nous aurions pu utiliser d'autres matières.  Il est à noter que des impressions échouent régulièrement. Tout d'abord, il y a une légère dilatation du filament parfois. Ensuite, si les modèles n'ont pas été bien préparés, s'ils sont trop proches ou les supports mal mis, toute l'impression sera à refaire. Ainsi, il faut être patient pour utiliser ce matériel qui, bien que très pratique, reste capricieux.

Impression 3D en résine
Les systèmes cristallins avec symétries ont été imprimés à l'imprimante résine ELEGOO Saturn. Cette méthode d'impression a l'avantage d'imprimer précisément des objets avec des formes complexes.

L'imprimante fonctionne en exposant la résine liquide photosensible couche par couche à un faisceau laser d'ultraviolets (UV). Au contact des l'UV, la résine se solidifie pour former le modèle souhaité. Il faut noter que l'impression résine requière un traitement une fois les objets imprimés. En effet, si ce traitement n'est pas réalisé rapidement, les résidus de résine inutilisés continuent de polymériser dans le bac d'impression, ce qui abime le matériel.

Il faut également veiller à mettre un peu plus de résine dans le bac d'impression que le volume indiqué par Chitubox afin d'être sûr que les objets soient imprimés entièrement.

Découpeuse vinyle
Plotter de découpe Graphtec Cutting Pro série 9000
Il s'agit de l'appareil le moins facile d'utilisation. Il nous a fallu près d'un mois pour comprendre que seul les MacBook fonctionnaient dessus.

En temps normal, il faut tout d'abord disposer son film dans l'appareil puis ajuster les têtes servant à le maintenir. Ensuite, il faut définir la zone de démarrage pour la découpe. Il suffit, dans la théorie, de brancher son ordinateur avec le logiciel Graphtec Studio pour faire le dessin de la découpe et l'envoyer à la machine. Après, on récupère le film découpé. Il faut noter que la force et la vitesse de la lame doivent être réglées en amont afin de ne pas abimer le film. D'ailleurs, pour le notre, tout le papier ne devait pas être tranché. Juste la partie supérieure. Ensuite, il faut le décoller de la partie protectrice du film et enfin faire la pose.

Cutter à ultra-sons
C'est un couteau amélioré. La lame envoie des ondes ultra-sons permettant une découpe sans forcer sur des surfaces peu pratiques à découper avec un cutter classique. Cependant, l'appareil chauffe très vite, il ne faut pas laisser la lame active trop longtemps. De même, il faut faire attention puisqu'il coupe des matériaux résistants comme le métal.

Chitubox
Chitubox est un logiciel d'adaptation des fichiers stl pour les impressions 3D en résine. C'est un slicer qui permet de convertir un fichier stl en une série de fines couches lisibles par l'imprimante ELEGOO Saturn.

Sur le même principe que le logiciel IdeaMaker, il permet de générer des supports pour maintenir les objets pendant l'impression. Le logiciel renseigne des dimensions de l'imprimante afin que nos modèles soient bien positionnés sur la plateau d'impression. Il est également possible de modifier le temps d'exposition de chaque couche à l'UV.
Cependant, à la différence d'IdeaMaker, il est important d'incliner les objets à imprimer afin que le moins de surface de l'objet ne touche le support d'impression. En effet, plus la surface de contact entre l'objet et le plateau est grande et plus il sera difficile de décoller les pièces et par conséquent plus il sera facile de les abimer.

Graphtec Studio
C'est le logiciel permettant de créer les formes pour la découpeuse vinyle. Il s'agit de dessin vectoriel. Le logiciel est pratique d'utilisation et intuitif. Il suffit ensuite de relier son ordinateur à la découpeuse pour obtenir le rendu souhaité. Il est possible de régler dessus les caractéristiques de force, vitesse et profondeur de la lame par l'intermédiaire de ce logiciel en fonction du film inséré.

Microscope Keyence
C'est un microscope de recherche utilisé par M. Labrousse dans le cadre de son travail. Il nous a permis de visualiser les impressions résines et de faire des topographies. Il est relié à un ordinateur et il est presque entièrement contrôlé par celui-ci. Il est plus puissant que les microscopes traditionnels puisque sa résolution est de l'ordre du micromètre.

VI- Bibliographie
Cours en ligne de cristallographie géométrique : SYMCRISCours de Matériaux inorganiques LU3CI013
VII- Remerciements
Nous tenons à remercier nos encadrants Monsieur LoÏc Labrousse et Monsieur Pierre Thery qui ont apporté leurs soutiens ainsi que leurs idées durant la réalisation de ce projet. Merci également à Monsieur Mathieu Chassé de nous avoir accordé sa confiance pour la réalisation de son projet. Sans oublier, l'équipe Fablab que nous remercions pour leurs aides et leurs conseils.

Cette UE Fablab, nous a permis de découvrir de nouvelles compétences scientifiques telles que la minéralogie et la cristallographie mais également des notions de programmation. Par ailleurs, ce projet nous a donné l'opportunité d'utiliser de nombreux logiciels (Chitubox, Ideamaker, Openscad) et machines de prototypage. Ces nouvelles compétences nous seront précieuses dans la poursuite de nos études ainsi qu'au cours de notre vie professionnelle. Expérience de Herschel


Lara et Louis vous présentent le wiki de leur projet, bonne lecture !

0 - Introduction

          Pour commencer, nous allons présenter l'expérience d'Herschel. À travers cette expérience, William Herschel, un astronome allemand du 18ème siècle, va mettre en évidence le caractère plus énergétique des rayons infrarouges. En plaçant un prisme à la lumière du soleil et à l'aide de thermomètres placés au niveau des différentes couleurs, il va faire le constat suivant : plus on va vers le rouge plus la température est importante. De plus, il observe que plus loin du spectre, hors du visible, dans ce que l'on appelle aujourd'hui l'infrarouge, il enregistre aussi des températures plus élevées; constat qui va aider par la suite à la découverte des infrarouges.

Voici grossièrement ce que l'on observe après une exposition prolongée aux deux extrémités du spectre. On note une différence de température mais au bout d'un certains temps d'exposition.

Le but de ce projet est de remettre au goût du jour cette expérience, avec comme objectif supplémentaire de pouvoir la présenter à la Fête de la Science. On avait donc un cahier des charges assez précis : Il faut la rendre pédagogique et facile à comprendre pour des non-initiés ou bien des futurs scientifiques, mais aussi simple à mettre en place, pratique et portable. Il est également important d'obtenir des résultats dans différents environnements, comme en extérieur et ce, peu importe les conditions météorologiques.

Tout d'abord, lors de la séance de choix des sujets, on a déjà pu commencer à discuter avec nos enseignants, Loic Labrousse et Pierre Thery pour prendre en main le sujet et nous aiguiller pour correctement mettre en place notre démarche scientifique. De plus, nous avons pris un rdv avec le chercheur ayant proposé le sujet, M. Ehouarn Millour, pour comprendre ce qu'il souhaitait faire et comment le réaliser.
Notre projet et ce wiki s'articulent de la façon suivante :

Recherche sur le spectre et le support

Comment prendre et analyser les données

Commençons donc avec la première partie sur le spectre et le support.

1 - Spectre et Support

1-a ) Le spectre

         Dans un premier temps, il fallait faire apparaitre un spectre à l'aide d'un prisme et d'une source de lumière à l'infini, pour que la diffraction soit possible. Pour faire un rappel rapide d'optique : une source dite infinie est une source où tous les rayons sont parallèles et vont dans la même direction, ce qui est le cas du soleil car avec la distance ses rayons sont considérés comme tels. Pour reproduire cela, avec une source de lumière "classique", il faut une lentille convergente, connaitre son point focal et placer le prisme à cet endroit comme ci-dessous :

Ensuite, la lumière passe dans le prisme et il décompose la lumière blanche en ses différentes composantes :

Après quelques tentatives plus ou moins fructueuses, Pierre Thery nous a trouvé un projecteur avec tout le montage préinstallé ce qui nous a facilité la tâche. Ce projecteur constituera notre source de lumière pour la suite, mais il est bon de savoir créer un spectre avec des moyens plus simples en cas d'absence de ce genre de matériel.

C'est une lumière halogène qui émet dans toutes les longueurs d'ondes avec la répartition suivante :

Après avoir comparé avec les autres types de lampe, la lampe halogène était la plus adéquate pour y voir des infrarouges, car ils y sont les plus présents et se rapprochent le plus de l'homogénéité de la lumière du soleil :

En comparaison voici les spectres des spectres des LED "warm white" et "daylight"

warm white

daylight
1-b) Le support

         Pour la suite nous avons créé, à l'aide du logiciel de modélisation OpenScad, un support pour le prisme afin qu'il ne soit pas en contact du sol et qu'on puisse le manipuler à sa base sans y laisser de trace de doigt. Nous avons également modélisé une fente pour que la lumière soit encore plus concentrée. Ces objets ont ensuite été imprimé grâce aux imprimantes 3D présentes dans le FabLab de Jussieu. Dans le même temps, nous avons pris une plaque de plexiglass qui nous servira de support. À l'aide d'une découpeuse laser, nous l'avons découpé pour obtenir les dimensions désirées (40x40 cm). En outre, afin de visualiser correctement le spectre (le plexiglass n'étant pas un matériau optimal car transparent), nous avons choisi de coller dessus un vinyle blanc.

 Plaque de plexiglas avant recouvrement avec un vinyle blanc.
Pour que notre dispositif se maintienne correctement, nous avons aussi modélisé et imprimé des pieds capables de stabiliser la plaque de plexiglass :

2 - Prise et analyse des données

   Dans cette partie, l'idée était de remplacer les thermomètres utilisés par W. Herschel par des moyens plus modernes de prise de données, mais aussi de moderniser le support de lecture et de visualisation.
2-a) Acquisition de la température

          Tout d'abord il faut correctement placer les capteurs en accord avec ce que l'on doit mesurer. En effet, le premier problème était le suivant : où placer le capteur des infrarouges par rapport au reste du spectre ?  Pour répondre à cette question, on utilise la loi de Bragg afin de déterminer l'endroit où les infrarouges sont au maximum, comme on le voit avec le schéma ci-dessous :

Il faut placer notre capteur pour les infrarouges à 1,4 fois la distance du spectre. Ainsi, si l'on a un spectre de 10 cm de large, la zone où les infrarouges sont les plus présents se trouve à 14 cm du début du spectre (en partant du violet).
Dans l'optique de moderniser la prise de données, après discussion et recherches, nous nous sommes orientés vers des capteurs de température de type LM35DZ :

Ce sont des capteurs de températures analogiques, fonctionnant entre 4 et 30 volts d'alimentations et ayant une précision de +/- 0.5°C à 25°C, mais pouvant mesurer des températures entre -55 et +150°C. Il dispose de plusieurs parties : un boitier noir, une broche +, une - et une sortie d'information :

Il mesure la température avec un capteur thermosensible dans son boitier noir et va ensuite transmettre une tension électrique qui sert d'information, avec le calibrage de 10 mV/K :

Capteurs que vous pouvez trouver à l'adresse suivante :

https://www.mouser.fr/ProductDetail/Texas-Instruments/LM35DZ-NOPB?qs=QbsRYf82W3F5RpWTxhXHxA%3D%3D
Avec ces capteurs, il fallait de quoi traiter les données et les afficher. Nous avons pensé à une carte Arduino qui, avec un code informatique, récupère et affiche les données. Voici une photo pour se représenter la carte électronique :

Pour que cela ait lieu, on doit réaliser un circuit électronique afin de connecter tous les capteurs à la carte.
En effet, comme on doit montrer la différence de température entre les rayons infrarouges et le reste du spectre, il faut placer plusieurs capteurs afin de mesurer les températures à différents endroits du spectre. Le placement des capteurs sur la plaque perforée a donc toute son importance. On a alors décidé de placer 6 capteurs qui vont nous renseigner sur les températures : de l'infrarouge, du rouge, du jaune, du bleu, du violet et enfin un témoin.

Passons donc à la réalisation du circuit.

2-b) Circuit électronique

         Après quelques recherches, on a utilisé une breadboard car elle a comme atout de pouvoir placer et retirer à notre bon vouloir les composants, ce qui va nous permettre de faire le circuit avant de le souder définitivement sur une plaque perforée. Effectivement, on n'est pas à l'abris de faire des erreurs de branchement mais surtout on peut aisément faire des essais de circuit, une découverte pour nous.
On a appris qu'il fallait les placer en dérivation, ce qui impliquait une sortie de données par capteur ainsi qu'une alimentation pour chacun et des condensateurs 100 nF pour ne pas surcharger le capteur.
Voici un schéma du montage réalisé sur fritzing, un logiciel de conception de circuit, avec :

câbles bleus :  sortie analogique (donnés)
câbles rouges et noirs : alimentation ( + et - )
composants bleus :  condensateur

composants noirs :  capteur de température

Ceci est un schéma, si l'on souhaite mettre plus de capteurs il faut simplement ajouter un autre en suivant la même mise en place. Cependant, si on en met trop il faudra ajouter une alimentation supplémentaire à la carte pour avoir assez de courant car il est branché en USB à l'ordinateur.

Il faut bien veiller à comment placer les capteurs dans le circuit car mal placé il chauffait beaucoup (quelques légères brûlures du bout du doigt ont été à déplorer) il faut donc bien respecter le sens du courant.  

Pour faciliter la compréhension du circuit nous avons utilisé des fils blancs et noirs pour l'alimentation (respectivement + et -) et des fils de couleurs à l'image du placement des capteurs sur le spectre (fil rouge pour rouge...) pour directement savoir quel fil appartient à quel capteur.

Voici donc le montage avant soudure :

2-c) Traitement des données (code)

         Une fois le montage électronique réalisé, il faut que notre dispositif puisse récupérer et afficher les données. Pour cela, on utilise une carte Arduino qui exécute un code que l'on écrit, encore faut-il l'écrire. En effet, Arduino utilise le langage C++, un langage que nous ne maîtrisions pas au début de ce projet, ce qui a rendu la tâche un peu compliquée et qui nous a pris une bonne partie de notre temps. Avec l'aide de Loic Labrousse, Pierre Thery et de recherches sur internet, nous avons réussi à écrire un code fonctionnel.

Dans ce code, il fallait premièrement récupérer les données du capteur et les stocker dans des variables (une pour chaque température souhaitée). Deuxièmement, il fallait convertir la tension en température et enfin afficher les données sous forme de courbe. En effet, ce genre de figure est adéquat pour visualiser et comprendre rapidement les variations. Ici, ce qui est intéressant, c'est que l'on voit les courbes directement après la réception des données et donc on visualise les variations en temps réel.

Code LM35DZ

Ceci est un code qui fonctionne avec les capteurs LM35 de chez texas instrumental 
avec une précision de +/- 0.5°C :

int sensePin0 = A0;
int sensePin1 = A1;
int sensePin2 = A2;  //This is the Arduino Pin that will read the sensor output
int sensePin3 = A3;
int sensePin4 = A4;
int sensePin5 = A5;

int sensorInputIr;
int sensorInputRouge;  //The variable we will use to store the sensor input
int sensorInputJaune;
int sensorInputVert;
int sensorInputBleu;
int sensorInputViolet;

double tempIR;
double tempRouge;  //The variable we will use to store temperature in degrees.
double tempJaune;
double tempVert;
double tempBleu;
double tempViolet;

void setup() {

 // put your setup code here, to run once:

 Serial.begin(9600);  //Start the Serial Port at 9600 baud (default)

 pinMode(sensePin0, INPUT);

 pinMode(sensePin1, INPUT);

 pinMode(sensePin2, INPUT);

 pinMode(sensePin3, INPUT);

 pinMode(sensePin4, INPUT);

 pinMode(sensePin5, INPUT);
}
void loop() {

 // put your main code here, to run repeatedly:

 sensorInputIr = analogRead(sensePin0);

 sensorInputRouge = analogRead(sensePin1);

 sensorInputJaune = analogRead(sensePin2);

 sensorInputVert = analogRead(sensePin3);  //read the analog sensor and store it

 sensorInputBleu = analogRead(sensePin4);

 sensorInputViolet = analogRead(sensePin5);

 tempIR = (double)sensorInputIr  /1024 ; 

 tempRouge = (double)sensorInputRouge /1024 ;  //find percentage of input reading

 tempJaune =  (double)sensorInputJaune /1024 ; 

 tempVert = (double)sensorInputVert / 1024; 

 tempBleu = (double)sensorInputBleu / 1024;

 tempViolet = (double)sensorInputViolet / 1024;

 tempIR = tempIR * 5*100;    //multiply by 5V to get voltage

 

 tempRouge = tempRouge * 5*100;

 

 tempJaune = tempJaune * 5;

 tempJaune = tempJaune * 100;

 tempVert = tempVert * 5;

 tempVert = tempVert * 100;

 tempBleu = tempBleu * 5;

 tempBleu = tempBleu * 100;

 tempViolet = tempViolet * 5;

 tempViolet = tempViolet * 100;

 

 Serial.print("tempIR: ");

 Serial.println(tempIR);

 Serial.print("tempRouge:");

 Serial.println(tempRouge);

 Serial.print("tempJaune:");

 Serial.println(tempJaune);

 Serial.print("tempVert:");

 Serial.println(tempVert);

 Serial.print("tempBleu:");

 Serial.println(tempBleu);

 Serial.print("tempViolet:");

 Serial.println(tempViolet);

 

 delay(1000);

 /*Serial.print(tempIR);
Serial.print(" ");
Serial.print(tempRouge);
Serial.print(" ");
Serial.print(tempJaune);
Serial.print(" ");
Serial.print(tempVert);
Serial.print(" ");
Serial.print(tempBleu);
Serial.print(" ");
Serial.print(tempViolet);
Serial.println();
delay (1000);*/
}

Voici une photo des courbes que nous avons obtenues avec ce code :

Cependant la précision n'était pas suffisante pour voir la différence de température comme on le voit sur la photo. De plus, les courbes se coupent beaucoup trop pour avoir un résultat satisfaisant. Nous avons donc chercher d'autres types de capteurs et en avons trouvé avec le même fonctionnement mais plus précis : le LMT86LP avec une précision de +/- 0.25°C à 25°C.

On a refait un code car le traitement est différent, notamment la conversion tension / température, mais, pris par le temps et la capacité à refaire un code rapidement, nous n'avons pas pu le finir.

Code LMT86LP
Voici ici le code qui sera retravaillé car ne fonctionne pas correctement actuellement. (un problème au niveau de la fin et du plot, les valeurs de températures sont pourtant correctes) :

// création des variables qui vont stocker la sortie du capteur

// initialisation des pins de sortie
int IR = A0;
int Rouge = A1;
int Vert = A2;
int Violet = A3;
int UV = A4;
int Tt = A5;

int TempReadIR = 0;
int TempReadR = 0;
int TempReadVert = 0;
int TempReadV = 0;
int TempReadUV = 0;
int TempReadT = 0;

int TemperatureIR = 0 ;
int TemperatureR = 0 ;
int TemperatureVert = 0;
int TemperatureV = 0;
int TemperatureUV = 0  ;
int TemperatureT = 0;

double TIR;
double TR;
float TVE;
float TV;
float TUV;
float T ;

// double = float, pareil creation de variable

float voltage = 0;

// setup : mise en place des sorties et des configurations
void setup()
{

 Serial.begin(9600); // initie la communication avec le serial monitor

 // on se place à 9600 bauds, la sortie de bits/s ( jsp ca change quoi mais si on met autre chose ca fonctionne plus)

 pinMode(IR, INPUT);

 pinMode(Rouge, INPUT);

 pinMode(Vert, INPUT);

 pinMode(Violet, INPUT);

 pinMode(UV, INPUT);

 pinMode(T, INPUT);

}
// loop = ce qui va se répéter 

void loop()
{

// ceci sont les transformations des donnés de voltage en température ainsi que les prints pour faire apparaitre

// sur le monitor ou le plotter 

 // exemple de lecture de donnée du capteur analogique (1) et de la conversion en température (2)

 TempReadIR = analogRead(IR); //  (1)

 TIR = (426.0 - TempReadIR) / 2.14; // (2)

 // la converstion était de  (420 - T)/2.206 mais celle la fonctionne mieux

 Serial.print("Temperature IR is ");

 Serial.print(TIR);

 Serial.println("°C");

 TempReadR = analogRead(Rouge);

 TR = (426.0 - TempReadR) / 2.14;

 Serial.print("Temperature Rouge is ");

 Serial.print(TR);

 Serial.println("°C");

 TempReadVert = analogRead(TVE);

 TVE = (426.0 - TempReadVert) / 2.14;

 Serial.print("Temperature TVE is ");

 Serial.print(TVE);

 Serial.println("°C");

 TempReadV = analogRead(Violet);

 TV = (426.0 - TempReadV) / 2.14;

 Serial.print("Temperature V is ");

 Serial.print(Violet);

 Serial.println("°C");

 TempReadUV = analogRead(UV);

 TUV = (426.0 - TempReadUV) / 2.14;

 Serial.print("Temperature UV is ");

 Serial.print(TUV);

 Serial.println("°C");

 TempReadT = analogRead(Tt);

 T = (426.0 - TempReadT) / 2.14;

 Serial.print("Temperature T is ");

 Serial.print(T);

 Serial.println("°C");

 // le delay est le temps en millisecondes entre chaque mesure (à modifier si nécessaire, en fonction de ce que l'on veut faire)

 delay(3000);
}

Si vous souhaitez convertir les degrés Celsius en Farenheit et l'afficher aussi, ajoutez simplement ces lignes de code :

 Temperature = (Temperature * 9.0 / 5.0) + 32;

 Serial.print("The temperature is ");

 Serial.print(int(Temperature));

 Serial.println("F"); */

3 - Mise en place finale

Pour rendre le tout plus propre, et une fois qu'on était sûrs que le circuit soit le bon, nous avons soudé le tout sur une plaque perforée avec le schéma suivant :

photo d'une plaque perforée

La soudure s'est avérée plus compliquée car cela faisait un certain temps que nous n'en avions pas faite et il ne fallait pas que les soudures se touchent sinon cela induirait un court circuit.

De plus pour ajouter un côté esthétique nous avons fait un design de logo pour identifier notre expérience et y placer le logo du FabLab, et le nom de Sorbonne Université. A l'aide du logiciel Inkscape, nous avons créé et vectorisé le dessin du logo ci-dessous et, avec une découpeuse laser qui sert aussi à la gravure, nous avons apposé le logo sur une plaquette de bois.

Nous avons collé un vinyle noir par dessus et fait des trous pour faire passer les capteurs car on trouvait cela plus propre que la plaque orange. Ainsi, une fois le spectre réalisé, le support monté et la plaque prête, voici notre montage final :

De plus, pour rendre l'information accessible facilement, nous avons fait un QR code, qui sera collé sur le montage, menant à cette page si des curieux veulent toutes les informations :

Journal de bord
Pour bien se rendre compte de notre avancée au cours du semestre, voici notre journal de bord retraçant notre parcours avec nos réussites et échecs. Il a été écrit semaine après semaine en fin de séance par nos soins avec le plus de précision possible.

Journal de bord
Semaine 0 :
Présentation des différents sujets, des locaux, des enjeux. Choix de notre sujet.
Première prise de contact avec le chercheur Ehouarn Millour du LMD IPSL. Travail personnel de recherches d'informations en lien avec le sujet (contexte, gamme de valeurs sur les températures et sur les longueurs d'onde), premiers schémas.
Semaine 1 :
Premier rendez-vous avec Monsieur Millour : présentation du cahier des charges :
Objectif : refaire l'Expérience de Herschel dans le but de la présenter à la Fête de la Science.
Présentation du matériel déjà à disposition (lampe + ampoule halogène 50W, 1 prisme normal, 1 prisme grand)
Premières ébauches de réflexion quant aux enjeux : la lampe? comment récupérer la température? la traiter? le prisme de diffraction est-il exploitable?
Recherche de capteurs de températures au Fablab.
Expérimentation de l'Arduino et des thermocouples pour la récupération de données sur l'ordinateur, réalisation d'une courbe de donnée brute pour visualiser les variations de température. Afin de récupérer la température, on pense à une barre en plexiglass où les thermocouples vont être placés.
Réalisation des premières expériences avec le prisme et observation des spectres de diffraction : résultats peu concluants : spectres non exploitables : trop diffus, la lumière se recompose en lumière blanche : aucune précision dans le spectre.
On prévoit 8 thermocouples (violet, bleu, vert, jaune, orange, rouge, IR, témoin) ou capteurs de températures.
Prochainement :
- posséder un condensateur optique
- refaire l'expérience plus précisément
- essayer de former notre Arduino
- comparer avec un réseau pour voir si c'est mieux qu'un prisme

Semaine 2 :
Premiers pas et apprentissage du logiciel Openscad :
Conception d'un support du prisme sur ce logiciel
Mise en place de l'expérience approfondie, test des différents prismes et des lampes : lampes fournies/projecteurs
Exemples de test de diffraction pour placer les thermo-couples
Recherche d'une lentille auprès de JP Ferreira
Prochainement :
- imprimer en 3D le support du prisme
- avancer les recherches personnelles sur les lampes et prismes

Semaine 3 :

Obtention d'un spectre lumineux exploitable pour l'expérience, il était beau.

Réalisation d'une fente sur le logiciel OpenScad et test d'impression 3D dans la salle Image. Test infructueux --> Direction Fablab bâtiment Esclangon pour une nouvelle impression 3D. Durée : environ 1h15. Coût : 0,64€. Poids : 21,3g.
Recherche internet des thermocouples afin de faire des tests : voir si on détecte une variation de température significative.

Semaine 4 :

Première utilisation de notre super fente malheureusement elle semble trop petite : elle atténue trop la lumière et donc le spectre. On va donc garder notre "rond" qui est, on vient de l'apprendre, un embout de tuyau imprimé en 3D pour l'expérience de DARCY. On a ensuite fait des tests de prise de température avec les thermocouples et un code Arduino qui s'est avéré plus compliqué que prévu. En effet, le code a fonctionné au départ puis mystérieusement plus du tout; problème que l'on essaye de régler en ce moment avec l'aide de Loïc et Pierre.

On a ensuite lancé l'impression de notre 2ème pièce d'orfèvrerie en impression 3D : un support pour notre prisme pour ne pas l'endommager plus que de raison. Durée :  1h17. Cout : 0,37€. Poids : 12g.
En somme une semaine mouvementée.
Prochainement :

- se renseigner sur les arduinos et les ThC, les commander. Trouver tuto pour faire un code correct qui marche.
recherche internet et lien :

https://www.mesurex.fr/non-classe/comment-choisir-son-thermocouple/
https://learn.adafruit.com/thermocouple/wiring-a-thermocouple
https://forum.arduino.cc/t/question-sonde-thermocouple-et-larduino/130848/9
https://www.tcsa.fr/thermocouples/thermocouple-patch.html

Semaine 5 :
Récapitulatif des choses à faire :
- acheter 8 thermocouples DEMANDER A PIERRE
- trouver un écran en plexiglass noir (Fablab) / y faire 8 trous
- s'occuper de la partie électronique
Semaine 6 :
thermocouple et voir s'il faut un amplifier
http://emery.claude.free.fr/arduino-capteur-temperature.html/
https://www.carnetdumaker.net/images/montage-de-lexemple-arduino-lm35/
https://www.raspberryme.com/guide-des-capteurs-de-temperature-lm35-lm335-et-lm34-avec-arduino/
Commande de capteurs de températures LM35
Le capteur de température LM35 est un capteur analogique de température fabriqué par Texas Instruments. Il est extrêmement populaire en électronique, car précis, peu couteux, très simple d'utilisation et d'une fiabilité à toute épreuve.
Le capteur de température LM35 est capable de mesurer des températures allant de -55°C à +150°C dans sa version la plus précise et avec le montage adéquat, de quoi mesurer n'importe quelle température.
La sortie analogique du capteur est proportionnelle à la température. Il suffit de mesurer la tension en sortie du capteur pour en déduire la température. Chaque degré Celsius correspond à une tension de +10mV.
La version plus précise du LM35 (nommée "LM35A") a une précision garantie de +/-0.5°C à 25°C et +/-1°C à -55°C ou +150°C.
Le capteur LM35 fonctionne avec n'importe quelle tension d'alimentation comprise entre 4 volts et 30 volts, ce qui permet de l'utiliser dans virtuellement n'importe quel montage numérique ou analogique. Le capteur LM35 ne fonctionne pas en dessous de 4 volts, donc oubliez l'utilisation d'un LM35 avec des cartes Arduino 3.3 volts (Due, Zero, etc), sans alimentation 5 volts externe, ça ne marche pas.

Mise en évidence rapide des variations de température à l'aide d'un thermomètre classique :

On voit que la température est plus élevée sur la photo de gauche (quand la température est mesurée dans le rouge), et plus basse dans la photo de droite (dans le violet).

Préparation du montage avec tous les composants nécessaires sauf les capteurs de températures LM35DZ :
- condensateur 100 nF
- breadboard + fils
- carte Arduino Méga 

Il reste à déterminer si l'on réalise un montage en série ou en dérivation. Si dérivation, besoin de 8 condensateurs.
Nous avons été cherché au Fablab : 8 condensateurs et un breadboard.
Référence capteurs à commander :
https://fr.rs-online.com/web/p/capteurs-de-temperature-et-d-humidite/8115595

Semaine 7 : 
On a commandé les thermocouples et on les attend. En attendant, on voit pour le circuit imprimé et on répond à Claude.
On associe chaque couleur du spectre à un câble de cette même couleur.
On a vu qu'il fallait mettre tout les capteurs en dérivation ce qui complexifie le câblage mais rend le traitement de données plus simple.
source :
https://forum.arduino.cc/t/multi-sensor-lm35/584761

La partie du LM35DZ qui détecte la température est appelée "élément sensible", il s'agit d'une petite puce située au centre du boitier en plastique noir.   
Nous avons ensuite réfléchi sur l’esthétique du support :  les composants seront exposés face visible pour rendre les explications plus faciles et pédagogiques. Ils seront collés sur une plaque de plexiglass avec une gravure de nos prénoms pour les royalties, ainsi que le logo Fablab et celui de SU. De plus, il faut que nous réalisions un support pour maintenir la plaque de plexi à la verticale pour plus de confort.
Après avoir fait les tests sur breadboard, nous allons réaliser notre propre circuit imprimé qu'on devra réaliser et souder nous-même.

Semaine 8 :
On n'a toujours pas reçu les thermocouples. La première commande n'a pas abouti donc il a fallu en faire une deuxième.
Aujourd'hui, on va s'occuper de la plaque de plexiglass, la couper aux bonnes dimensions si besoin et aussi réaliser son support.
On a été chercher la plaque qu'on a ensuite découpé au laser aux dimensions 40x40 cm. On a modélisé les pieds de support et notre logo.

Prochainement : imprimer le support et la gravure de notre logo.

Semaine 9 :
Mercredi :
On a reçu les thermocouples. On a pu réaliser le montage du câblage (voir photo). Malheureusement, après de nombreuses tentatives d'écritures du codage Arduino, on ne parvient pas à en trouver un qui fonctionne.

On a également fini de designer notre logo (voir photo)

On va maintenant aller lancer la gravure de notre logo et imprimer les supports de notre plaque.
Jeudi : 
On est parti graver notre logo mais on va le refaire car il ne nous convenait pas parfaitement. On a aussi lancé l'impression de nos supports pour tenir notre plaque de plexi mais elle a échoué, nous allons donc devoir en relancer une autre.
Echec de l'impression des supports de la plaque...
Vendredi : 
Avec Loic et Pierre, nous avons mis beaucoup de temps avant de réaliser un code qui fonctionne. En effet, on pensait que notre montage manquait d'une résistance (même deux), que la carte Arduino MEGA 2560 ne marchait pas, ou encore qu'il y avait un problème dans les branchements des fils alors qu'en réalité, le problème venait seulement du monitor.
Nous avons choisi un code écrit par Claude (cf Le Blog de Claude) mais il est valable que pour un capteur donc nous devons le modifier pour qu'il nous renseigne les températures de nos 6 capteurs.
On a été réalisé une deuxième fois notre gravure qui est meilleure.
On a été voir Stéphane au Fablab pour nous aider à corriger notre code Arduino. Au final, c'est avec l'aide du directeur du Fablab qu'on a pu trouver notre erreur et avoir un code qui marche. Notre erreur venait du fait que l'on avait placé nos thermocouples sur tout le long de la breadboard, en oubliant que celle-ci était divisée en deux au milieu, séparant ainsi le circuit électrique en deux. Le directeur nous a aussi écrit une partie du code permettant de visualiser les courbes de températures. Donc un grand merci à Christian Simon.

Semaine 10 :
Après deux tentatives, on a finalement, au bout de la troisième fois, réussi à graver un logo qui nous convient, avec les bonnes dimensions et le bon matériau.
 2 tentatives ratées : 1 trop grande et 1 avec un contraste de couleur trop faible
 Réussite !
Après l'échec de la semaine passée, on a aussi finalement réussi à imprimer les pieds de support de notre plaque !

 Les supports de notre plaque
"L’infrarouge, d’un autre côté, est un rayon physique caractérisé par une action de chaleur intense et une faible énergie."
"Plus la longueur d’onde IR est courte, plus le radiateur IR est « chaud » et plus sa chaleur est « transmissive », ce qui signifie qu’il peut parcourir de plus grandes distances dans des « faisceaux » plus étroits."
La lampe du projecteur (notre source de lumière) est une lampe halogène, ce qui convient le mieux pour avoir une maximum de rayonnement infrarouge.

Spectre d’une lampe halogène. Il présente une courbe régulière avec une forte proportion de rouge: la température de couleur se situe entre 2800 et 3000°K (lumière chaude). La lampe émet beaucoup de chaleur (rayonnement infrarouge = IR).Le spectre d’une ampoule incandescente classique est similaire, avec un décalage un peu plus marqué vers le rouge. (https://www.energie-environnement.ch/maison/eclairage-et-piles/1369)
On veut maintenant savoir comment placer les capteurs de températures, c'est-à-dire à quelle distance les uns des autres et surtout pour capter le maximum de température dans le rayonnement IR. Pour cela, on utilise la loi de Bragg (2dsinθ=nλ) pour déterminer à quelle distance placer le capteur pour qu'il reçoive le maximum d'énergie thermique infrarouge.

Calcul pour déterminer la distance couverte par le rayonnement IR le plus important. On en conclut que cette distance est 1,4 fois pour grande que celle couvrant le spectre du visible.
Potentiel capteur plus précis mais plus cher :
+/- 0.1°C
https://fr.farnell.com/ist-innovative-sensor-technology/tsic-501f-to92/capteur-de-temperature-10-a-60/dp/3879373
https://fr.farnell.com/ist-innovative-sensor-technology/tsic-503-to92-5v/capteur-temp-analogique-to92-3/dp/3587031
https://www.ist-ag.com/en/products/digital-temperature-sensor-ic-to93
+/- 0.25°C
https://fr.farnell.com/texas-instruments/lmt86lp/temp-sensor-0-25-deg-c-to-92-3/dp/3124226RL

Semaine 11 :
Les nouveaux capteurs ne sont pas arrivés.
On a décidé de prendre moins de capteurs mais de les placer à des endroits plus stratégiques : témoin, UV, violet, vert, rouge, IR.
On a été prendre une plaque perforée sur lequel faire notre circuit.
On y a placé les capteurs et les condensateurs.
Schéma de notre circuit

faire le vinyle
faire le circuit
tester avec les nouveaux capteurs

Semaine 12 :
On a reçu les nouveaux capteurs de températures.
On a replacé les capteurs sur notre plaquette car le spectre fait maintenant 5 cm.
En effet, on a remarqué que le spectre était de meilleure qualité, c'est-à-dire que les couleurs étaient plus intenses si l'on réduisait la surface d'une face du prisme, on a donc placé une feuille noire sur la face en aval du prisme. Ça induit une réduction de largeur du spectre.
On a été mettre un vinyle blanc sur la plaque au Fablab avec l'aide d'Alexandre. On a utilisé la découpeuse vinyle.
On n'a pas réussi à faire fonctionner le code avec les nouveaux capteurs.
A faire : faire fonctionner le code et faire le circuit

Semaine 13 :
Jeudi :
On est venus pour finaliser le code, on n'arrive pas encore à afficher le plot.
On a également réalisé les soudures nécessaires pour notre circuit.
Vendredi :
On a reconfectionné le circuit et mis le vinyle noir dessus et on y a fait des trous pour laisser passer les capteurs.
Aperçu du montage presque final

Remerciements
Nous tenons à remercier dans un premier temps nos encadrants, Loic Labrousse et Pierre Thery qui ont été présents tout au long du semestre apportant conseils, suivis mais aussi une aide logistique pour l'accès aux différentes salles et pour les commandes de matériels.
Nous remercions également M.Ehouarn Millour qui a proposé ce sujet, dans le cadre de cette UE Atelier FabLab, qui nous a de suite intéressée.

Enfin, un grand merci à tout ceux qui ont participé, d'une part en nous prêtant du matériel mais aussi en nous apportant conseils et aide dans notre démarche :

l'équipe du Fablab qui nous a montré comment utiliser les différentes machines et le prêt de certains composants
Jean-Philippe Fereira pour les conseils en optique

Stéphane Muller et Christian Simon pour l'aide sur le circuit et le code

Bibliographie
Voici tous les liens qui nous ont aidé à mener à bien le projet, ainsi que des liens de commande de capteurs si vous le souhaitez :

Bibliographie
https://www.mesurex.fr/non-classe/comment-choisir-son-thermocouple/
https://learn.adafruit.com/thermocouple/wiring-a-thermocouple
https://forum.arduino.cc/t/question-sonde-thermocouple-et-larduino/130848/9
https://www.tcsa.fr/thermocouples/thermocouple-patch.html
http://emery.claude.free.fr/arduino-capteur-temperature.html
https://www.carnetdumaker.net/images/montage-de-lexemple-arduino-lm35/
https://www.raspberryme.com/guide-des-capteurs-de-temperature-lm35-lm335-et-lm34-avec-arduino
https://fr.rs-online.com/web/p/capteurs-de-temperature-et-d-humidite/8115595
https://forum.arduino.cc/t/multi-sensor-lm35/584761
https://fr.farnell.com/ist-innovative-sensor-technology/tsic-501f-to92/capteur-de-temperature-10-a-60/dp/3879373
https://fr.farnell.com/ist-innovative-sensor-technology/tsic-503-to92-5v/capteur-temp-analogique-to92-3/dp/3587031
https://www.ist-ag.com/en/products/digital-temperature-sensor-ic-to93
https://fr.farnell.com/texas-instruments/lmt86lp/temp-sensor-0-25-deg-c-to-92-3/dp/3124226RL
https://arduino.stackexchange.com/questions/13289/arduino-uno-with-lmt86lp-temperature-sensor
https://www.carnetdumaker.net/articles/mesurer-une-temperature-avec-un-capteur-lm35-et-une-carte-arduino-genuino/
https://www.energie-environnement.ch/definitions/1369-spectre-lumineux-des-lampes-d-eclairage
Casagrande - Boite de cisaillement


Informations :

Tenue du wiki : Pierre Thery & Johane Dufour
Contact : johane.dufour@etu.sorbonne-universite.fr

Etudes : Licence 3 - Sciences de la Terre
Date du projet : Juin 2024
Encadrant : Pierre Thery

Sommaire :

Introduction et objectif du projet

Matériel, machines et logiciels utilisés

Conception de la boîte de Casagrande + Codes OpenSCAD

Journal de Bord

1. Introduction et objectif du projet

 L'objectif du projet est de reprendre la boîte de Casagrande utilisée les travaux pratiques de géotechnique/géophysique niveau L3. Elle permet de mesurer la résistance au cisaillement (cohésion C et angle de frottement interne Ф) et notamment pour un sable humide.

On reprend le projet précédent : wiki:projet:casagrande [FablabSU]

Suite aux multiples travaux pratiqués avec la précédente version, des points d'améliorations sont à prévoir:

Création de goupilles pour le remplissage de la boite, en effet le bras de levier entrainait le cisaillement avant même la manipulation
Prévoir l’installation sur pied car il est plus pratique de maniper à hauteur
Prévoir un butoir car une fois la rupture atteinte, le bras de levier de la force tangentielle descend jusqu'au sol
Solidifier la structure car elle n'était pas prévue pour une utilisation intense par des étudiants (plusieurs pièces cassés)
A voir: inclure un dynamomètre pour le calcul de la force tangentielle ou d'un montage Arduino + écran + capteurs FSR400 + R=10kOhm
-->https://www.instructables.com/Arduino-pressure-sensor-FSR-with-LCD-display/

2. Matériel, machines et logiciels utilisés
> Matériel nécessaire :

Capteurs FSR400
Carte Arduino Uno
Câbles Arduino
Module encodeur rotatif GT055
Planche de plexiglas de 6mm d'épaisseur
Écran LED

fablab

> Machines : Trotec Speedy 360 (découpeuse laser), Imprimante 3D, Perceuse
> Logiciels : OpenSCAD, Inkscape, Arduino IDE

3. Conception de la boîte de Casagrande + Codes OpenSCAD
> Impressions 3D :

Partie Basse Boîte
Fichier STL : AssemblageCasagrande - Casagrandeboitebasse-1-1.STL

Partie Haute Boîte
Fichier STL : AssemblageHaut2 - Casagrandeboitehaute-1.STL

Bouchon Boîte
Fichier STL : AssemblageCasagrande - Casagrandeboitebouchon-1-1.STL

Porte Poulie et Poulie
Fichier STL : Portepoulie.STL
Poulie.STL

Porte poulie et potentiomètre

Attaches Levier (x2)
Fichier STL : Attachelevierx2.STL

Photo de l'assemblage général de la boîte :

> Branchement du capteur FSR400 pour la force normale σN
On relie le capteur et l'écran à la carte Arduino en suivant le montage suivant : Instructables.com/Arduino-pressure-sensor-FSR-with-LCD-display/ et on choisit une résistance de 4K7 ohm lors du montage, pour avoir une valeur de poids affichée à l'écran la plus fiable au poids réel possible.

> Branchement de l'encodeur rotatif GT055
Afin de déterminer précisément le point de rupture, on utilise un encodeur rotatif qui va donner la valeur de déplacement en degrés. On le branche à une carte Arduino en suivant le montage suivant :

Source : LEXTRONIC, 2022 (https://www.lextronic.fr/module-encodeur-rotatif-51706.html)

Encodeur rotatif - Code Arduino
```cpp// Déclaration des variablesint CLK = 3;    // Broche CLK de l'encodeur sur la pin 3 de l'Arduinoint DT = 4;    // Broche DT de l'encodeur sur la pin 4 de l'Arduinoint encoderPosCount = 0; // valeur de départ de l'encodeur à zéroint CLKLast;int aVal;boolean bCW;
void setup() { pinMode (CLK,INPUT);  //  Pin CLK déclarée en entréepinMode (DT,INPUT);  //  Pin DT déclarée en entrée
CLKLast = digitalRead(CLK);  // Renvoi la dernière valeur de l'encodeurSerial.begin (9600);}
void loop() {aVal = digitalRead(CLK);
if (aVal != CLKLast) { // Indique que l'encodeur tourne// Si le bouton tourne, on déterminera son sens// avec la broche DTif (digitalRead(DT) != aVal) {  // si CLK change en premier - rotation dans le sens des aiguilles d'une montreencoderPosCount ++;bCW = true;} else { // sinon c'est DT qui change en premier et la rotation va donc dans le sens inversebCW = false;encoderPosCount--; }Serial.print ("Sens de rotation: ");   // Affichera le sens de rotationif (bCW){Serial.println ("clockwise");   // sens des aiguilles d'une montre}else{Serial.println("counterclockwise");   // sens inverse} Serial.print("Degré: "); 

Serial.println(encoderPosCount*9);   // Affiche la position de l'encodeur - comptage des impulsions} CLKLast = aVal ;}```

> Découpe laser

Découpe du Cadre
Fichier svg : 

Découpe des bras de levier
Fichier svg : 

Code OpenSCAD :

//dimensions du bras de levier
largeur = 40; //mm
diametreTrou = 4; //mm
nbUnites = 48; //nombre d'encoches
longueur = 500; //mm longueur de la barre à partir du trou

//dimensions des encoches
profondeurEncoche = 2; //mm
var = 0;

difference(){
 square([longueur, largeur]);
 //trou
 translate([0, largeur/2, 0]){
 circle(diametreTrou/2, $fn = 360);
 }
 //encoches
 for (i=[1:nbUnites]){
 var = i*10;
 translate([var, 0, 0]){
 rotate([0, 0, 45]){
 square([profondeurEncoche, profondeurEncoche], center = true);
 }
 }
 }
}

//Pour la forme arrondie
translate([0, largeur/2, 0]){
 difference(){
 circle(largeur/2);
 //trou
 circle(diametreTrou/2, $fn = 360);
 }
}

> Assemblage

4. Journal de Bord

Journal de Bord
5/06 : 
Branchement du capteur de pression Arduino

Tests de différentes résistances pour avoir un poids affiché à l’écran (en newton et en kg) fiable.
6/06 : 
> Création d’un socle permettant de tester le capteur de force (contrainte normale)
Afin de déterminer quelle résistance on utilise pour le capteur de force, on réalise en premier lieu un socle permettant de pouvoir tester différents poids sur le capteur. Le capteur étant très précis, il faut un système qui appuie parfaitement à l'endroit du capteur.

Code OpenSCAD pour le socle sous le capteur :

cotecube = 50 ; //mm

difference(){

 cube([cotecube,cotecube,10]);

 translate([0,20,0]){

 cube([25,10,3]);

 translate([25,5,0]){

 cylinder(r=6,h=3,$fn=100);

 }

 }

}

Code OpenSCAD pour la partie supérieure reposant sur le capteur :

cotecube = 50 ; //mm

cube([cotecube,cotecube,5],true);

translate([0,0,2.5]){

 cylinder(r1=5,r2=4,h=5,$fn=100);

}

> Impression du Socle du testeur

On crée le socle à l’aide de l’imprimante 3D :

7/06 : 
> Impression de la Partie Supérieur du test  
 Masse Partie Supérieur du test capteur : 7.0g
> Réalisation de différents tests avec différentes résistances électriques et différents poids

Poids réel (g)

Résistance 4K7 (g)

Résistance 10K (g)

Résistance 3K3 (g)

428

390

800 g

425

330

527

510

833

700

1800 (?)

600

Les tests ne sont pas très cohérents mais la résistance qui mène au poids le plus fiable est celle de 4K7 ohm.
10/06 :
> Dessin d’une pièce sur OpenSCAD pour mesurer la contrainte tangentielle mais abandon parce que ce système ne sera pas assez précis (effets de frottements qui vont fausser la valeur donnée par le capteur).
> Recherche d’un capteur de pression en S à utiliser à la place.

11/06 :
> Branchement de l'encodeur sur une carte Arduino, où on suit le montage suivant : https://www.lextronic.fr/module-encodeur-rotatif-51706.html

> Code Arduino : 
// Déclaration des variables
int CLK = 3; // Broche CLK de l'encodeur sur la pin 3 de l'Arduino
int DT = 4; // Broche DT de l'encodeur sur la pin 4 de l'Arduino
int encoderPosCount = 0; // valeur de départ de l'encodeur à zéro
int CLKLast;
int aVal;
boolean bCW;

void setup() {
pinMode (CLK,INPUT); // Pin CLK déclarée en entrée
pinMode (DT,INPUT); // Pin DT déclarée en entrée

CLKLast = digitalRead(CLK); // Renvoi la dernière valeur de l'encodeur
Serial.begin (9600);
}

void loop() {
aVal = digitalRead(CLK);

if (aVal != CLKLast) { // Indique que l'encodeur tourne
// Si le bouton tourne, on déterminera son sens
// avec la broche DT
if (digitalRead(DT) != aVal) { // si CLK change en premier - rotation dans le sens des aiguilles d'une montre
encoderPosCount ++;
bCW = true;
}
else { // sinon c'est DT qui change en premier et la rotation va donc dans le sens inverse
bCW = false;
encoderPosCount--;
}
Serial.print ("Sens de rotation: "); // Affichera le sens de rotation
if (bCW)
{
Serial.println ("clockwise"); // sens des aiguilles d'une montre
}else
{
Serial.println("counterclockwise"); // sens inverse
}
Serial.print("Degré: "); 
Serial.println(encoderPosCount*9); // Affiche la position de l'encodeur - comptage des impulsions
}
CLKLast = aVal ;
}

Pour chaque clic : indication d’une rotation de 18 degrés.

12/06 :
> Dessin du cadre sur Inkscape : 
Le cadre présente une encoche pour faire passer le bras de levier et un petit rectangle qui permettra d'appuyer sur le capteur pour la force normale.

14/06 : 
> Arrangement du cadre sur Inkscape
Pour que ce soit plus stable lors de l'utilisation.

> Second test du capteur - force normale
Lors des tests pour le capteur de la force normale, l'utilisation d'une résistance de 4K7 ohm menait à des poids proches de ceux réels. Bien que le capteur ne donne pas la valeur exacte, on réalise des tests avec différents poids pour voir si on peut trouver une relation de proportionnalité entre la valeur que le capteur nous donne et la valeur réelle :

Poids réel (g)

Poids avec Résistance 4K7 ohm (g)

103.3

0

200.8

140

249.2

140

454.8

410

534.3

510

840.8

740

836.1

Il faut multiplier la valeur donnée par le capteur par environ 1.3 pour obtenir la valeur de poids réelle, mais le capteur reste plutôt imprécis.
20/06 : 
> Visser pieds pour les bras de levier sous la table

> Visser socle boîte cisaillement et faire un trou pour vider la boîte du sable après utilisation : 

> Découpe laser bras de levier : 

> Découpe cadre : 

24/06 : 
On réalise des tests du capteur force normale avec le système entier : 

Poids éléments (méléments) :

> Bras : 134.2 g
> Cadre : 396.4 g 
> Total poids bras + cadre = méléments: 530.2 g
> Piston : 48.6 g
> Bouteille qu’on utilise pour la force normale meau : 857.8 g
Sans ajouter la bouteille, le capteur affiche : 9.59 N et 0.89kg

Calcul du facteur d'augmentation de la masse : f = L/

L : longueur entre l'articulation du bras de levier et l'encoche sur laquelle est posée la masse/la bouteillel : longueur entre l'articulation du bras de levier et l'encoche sous laquelle est glissée le cadre (fixe, 13 cm pour notre machine)

Calcul de la pression : P = m*g
m : masse en kg donc m = meau*f + melements
g : accélération : 9.81 m.s-2

Ici, melements = 530.2 g = 0.5302 kg et meau = 857.8 g = 0.8578 kg

Calcul en N : 
σN placé à la 26ième graduation donc P = (0.5302 + 26/13 x 0.8578) * 9.81 = 22.02 N = 2.24 kg --> capteur affiche moins de 1 kg
σN placé à la 28ième graduation donc P = (0.5302 + 28/13 x 0.8578) * 9.81 = 23.32 N = 2.38 kg --> mais capteur affiche moins de 1 kg
On réalise d'autre tests mais le capteur reste à 0.60 ou 0.80 kg quelque soit la graduation où on pose la bouteille --> imprécision du capteur, il ne doit pas bien capter le cadre posé dessus.

26/06 : 
On refait les tests avec un piston différent qui permet au capteur de mieux fonctionner : 

Numéro de graduation où est placée la bouteille
Pas de bouteille
26e
28e
35e
40e

Poids réel (N)
5.19

22.02
23.32
27.86
31.09

Poids par capteur (N)
5.37
10.36
17.07
32.03
45

Encore des incohérences dans le poids donné, on ne trouve pas relation de proportionnalité entre la réalité et les valeurs affichées par les capteur de force.
On pense alors utiliser différents capteurs pour capter le poids de la force normale: un capteur Arceli HX711 ADC
28/06 : 
Branchement du nouveau capteur pour la force normale : le capteur Arceli HX711 ADC

📟 MU5MN045 - Projets prototypage

Projets prototypage en groupe pour l'UE MU5MN045 - MMI

Consignes

Consignes du projet
Faire une preuve de concept ou une maquette d’un projet que vous définirez vous-mêmes (choix du projet et thème: libres). Vous documenterez l'ensemble du processus
Inclure au moins deux technologies vues en atelier : conception et impression 3D / conception 2D et découpe laser / électronique numérique

Deux approches possibles : concevoir un objet qui ressemble à l’objet final (éventuellement à l'échelle) ou bien un système électronique qui simule le comportement de l’objet final (mais ça peut être les deux à la fois)

Attendus de la documentation
Les éléments suivants doivent apparaître dans la documentation de votre projet :

définition du projet (besoin, utilisateurs, fonctionnalité principale, fonctionnalités secondaires)
réflexions sur la problématique et veille sur l'existant
lean canvas
choix techniques
gestion de projet: "minimum viable product", planification et répartition des taches
croquis, dimensions
liste du matériel
fichiers de conception et étapes de création des fichiers (captures d'écran) / code
photos et analyse des tests, essais, erreurs
photos des étapes de réalisation du prototype, paramètres des machines
photos de l'objet final
réflexions de pistes d'amélioration ou d'évolution du projet
sources des tutoriels, inspirations, ressources utilisées (à insérer au fil de la documentation)
Marine PIRUS, Ryan VICENTE & Eloïse CHOURAKI

GrowTogether : Planting seeds of Teamwork 🪴

Problématique de départ

Nous sommes partit d'un constat qui est le suivant :  Dans les entreprises, les plantes sont souvent mortes ou inexistantes parce que les employés n'ont pas le temps de les arroser. Les entreprises deviennent de moins en en moins végétalisées. Cependant, selon une étude réalisée par l’Université japonaise de Hyogo en 2019, avoir des plantes dans les espaces de travail diminuerait significativement l'anxiété des collaborateurs. Les plantes ont la capacité d’apaiser et de favoriser le bien-être des employés au travail : un réel atout pour une entreprise, car par effet ricochet cela permet aussi de limiter les risques psychosociaux, souvent facteurs de maladies ou de burn out. Il est donc d'intérêt publique de trouver une solution afin de végétaliser les espaces de travail et redonner du baume au coeur aux collaborateurs. (aller plus loin)
Solutions proposées et proposition de valeur

Afin de répondre à ce problème au sein des entreprises nous avons inventé GrowTogether, Planting seeds of Teamwork. Nous avons repensé la façon d'entretenir et d'arroser les plantes afin de simplifier la vie des collaborateurs. En effet, l'idée est de créer un module doté d'un capteur électronique d'humidité et aussi d'une LED afin de prévenir le propriétaire de la plante lorsque sa plante manque d'eau. Le module serait également relié à la boîte mail du collaborateur afin qu'il soit avertit lorsque sa plante aurait besoin d'eau. De plus, ce module serait emboitable avec les autres modules et l'on pourrait l'accrocher sur le mur afin de réaliser un mur végétal. Pour des soucis de temps et de moyen, ces deux dernières features ne seront pas prototypées dans le cadre de l'UE.
En plus d'apporter du "vert" dans les espaces de travail, GrowTogether permettrait également de responsabiliser et sensibiliser les collaborateurs en réalisant par exemple des matinées "Tout le monde plante". Lors de ces matinées, les différents collaborateurs pourraient planter leurs propres graines et ajouter leur module sur le mur végétal de l'entreprise. Ainsi, GrowTogether se veut être une solution qui végétalise les entreprises mais également une solution qui participe pleinement à la vie en entreprise en organisant des activités de team building ludiques qui ouvriraient les yeux des collaborateurs aux enjeux de l'environnement et à l'importance de la nature dans nos écosystème urbains. Notre solution réponds donc à un double enjeux écologique et sociétal pour la transition écologique des entreprises actuellement au coeur des débats (aller plus loin)
Technologies

Les technologies que l'on pourrait utiliser sont les suivantes :

Un pot en PLA (Polylactic Acid) imprimé en 3D qui contiendra l'eau (impression 3D)
Un capteur d'humidité permettant de savoir quand est-ce qu'il faut arroser sa plante (Électronique)
Un logo et une plaque personnalisable gravés dans du peuplier (Gravure et découpe laser)
Voyant LED permettant d'alerter le collaborateur

Un capteur/récepteur d'information (qui ne sera réalisé lors de l'UE)
Un pot en terre cuite qui s'insérera dans le pot imprimé afin de permettre à l'eau de s'infiltrer dans le substrat

Concurrence

Sur le marché actuel, nous avons pu identifier différents concurrents :

Semis qui lui est direct avec les particuliers et qui propose de l'aquaponie

Prêt à pousser qui propose des jardinieres connectés qu'il est possible de fixer sur un mur

Green Inside qui est propose un service d'entretien végétal dans les entreprises
Les plantes traditionnelles ou en plastique actuellement sur le marché

Avantage concurrentiel

GrowTogether se détache de la concurrence puisqu'il alerte les collaborateurs lorsque les plantes manquent d'eau. Il permet ainsi de totalement inclure les collaborateurs dans l'entretien de leur lieu de travail et les responsabilise en leur assignant une plante à entretenir. De plus, au delà du produit en lui-même, GrowTogether participe au team building et sensibilise les collaborateurs aux enjeux écologiques et sociaux du moment.
Planification des tâches

Déroulement du projet

Phase de reflexion
Dans un premier temps, comme nous l'avons dis précédemment : nous avons pensé à une idée et ensuite travailler sur celle ci. Pour cette phase de réflexion, nous avions décidé de regrouper toutes nos idées sur un tableau blanc pour faire un brainstorming. L'idée était de mettre sur un support l'ensemble des idées de features que nous avons eu et de les comparer avec celle de la concurrence afin de comprendre comment nous allions pouvoir nous démarquer et affirmer notre innovation. L'idée d'un bloc modulable pour mur végétalisé nous est apparue très clairement dans la tête. Nous voulions que la solution soit :

Simple

Frugale

Facile d'accès et d'entretiens

Facilement incorporable dans un espace intérieur de travail

Dans notre idée initiale, nous voulions réaliser un bloc (forme cubique) dans lequel nous pourrions installer directement la terre et la plante et nous voulions insérer la partie électronique de notre prototype à l'arrière de ce cube. Cependant, nous nous sommes rapidement rendu compte que ce type d'agencement ne serait pas optimal pour la captation de l'humidité par le capteur. En effet, il est plus simple de détecter un niveau d'eau bas dans un réservoir que le taux d'humidité du substrat. Nous avons donc dû repenser notre prototype afin qu'il réponde à notre nouvelle idée :

Après avoir imaginé l'ajout de membranes en tissus ou en plastique afin de laisser passer l'eau dans le substrat sans détremper la terre, c'est finalement sur la troisième version de prototype que nous nous sommes arrêté. En effet, nous avons eu l'idée d'ajouter un pot en terre cuite non-émaillé dans le prototype afin de laisser diffuser l'eau vers le substrat en fonction des besoins de la plante.
Phase de conception 3D du pot en PLA
Pour réaliser la base de notre projet, c'est à dire le pot, nous avons décidé de modéliser le tout en 3D à l'aide de Tinkercad puis Ideamaker.
Dans les premières modélisations, nous avons allongé le contenant afin de laisser pouvoir y mettre une grande quantité d'eau. Cependant, dans un soucis de masse et practicité, nous avons décidé de designer le bloc sur mesure pour un pot en terre cuite que nous avons acheté à Leroy Merlin. Ainsi, en accord avec les mesures du pot en terre cuite, nous avons designé le pot avec : L 100 mm, l 100 mm, H 85 mm. Nous avons ensuite réalisé deux orifices à l'aide de cylindres afin d'insérer le pot en terre cuite et de pouvoir remettre de l'eau dans le contenant.

Nous avons décidé de le réaliser en matière PLA et en couleur beige afin de rester dans les tons naturels. La pièce a été imprimée en remplissage 100%, 3 coques, avec un radeau et des supports (ce qui a permis d'avoir une impression parfaite dès le premier coup).

La pièce à mis 20 heures à être imprimée pour un coût estimé de 6,79€ (soit 226,3g ou 75,89 m de PLA).
     

Comme vous pouvez le voir nous avons créé un pot qui permet d'encaster le pot en terre cuite à l'intérieur de façon parfaite. L'arrachage des supports fut tortueux et il a fallu se protéger les yeux :

Phase de conception 3D du compartiment électronique en PLA
Il a été décidé que le circuit électronique permettant la détection de l'eau serait disposé sous le water-tank afin de faciliter la disposition de la LED sur la face du prototype. Afin de designer ce compartiment, nous sommes parti du modèle 3D du pot et avons effectué quelques ajustement afin de ne garder minimiser la hauteur du compartiment en fonction des pièces électroniques utilisées. Le compartiment fait donc : L 100 mm, l 100 mm et H 60 mm.

Cette pièce a été réalisée avec un remplissage à 50% et 3 coques sans supports et avec une bordure pour l'adhérence. Elle s'est imprimée en 6 heures pour un prix estimé de 2,34€ (77,9 g ou 26,11 m). Malheureusement, il ne restait pas assez de PLA beige pour réaliser l'impression (voir photo ci-après) :

Il a donc fallu rebondir et utiliser du PLA de couleur chocolat qui se mariait bien avec le PLA beige du pot. Voici le résultat de l'impression :

Phase de découpe laser du Logo
Avant de commencer la conception de notre logo et de notre plaque, nous avons fait des croquis pour voir quel agencement nous plaisait le plus.

Finalement, nous sommes partis sur l’option 1.
Nous avons décidé de désigner notre logo sur canva directement. Nous avons testé plusieurs alternatives différentes avec des polices différentes et une version sans le nom de notre marque.

Finalement, nous avons décidé de partir sur la dernière version, sans écriture, pour un look plus épuré et moins chargé.

Afin de réaliser notre logo, nous avons décider de le découper dans du contreplaqué de peuplier de 3mm. Pour cela, nous avons tout d'abord désigné le logo sur Canva avant de le vectoriser sur Inkscape en utilisant la fonction vectoriser un objet matriciel. Nous avons mis le logo en épaisseur 5 er en rouge afin que les traits se coupent.

Sur le logiciel, nous avons ensuite sélectionner l’intégralité de la forme > chemin > vectoriser une forme. Ce qui nous a donné ce rendu : 

Ensuite, nous avons inséré des contours rouges en faisant objet > fond et contour >  contour pour que la machine puisse découper les contours de la forme.

épaisseur : 1mm

couleur :  rouge

Le but était d’avoir le logo en transparence. Pour cela on a donc laissé la ligne en noir, qui sera gravé/marqué par la machine donc plus foncé par rapport à la feuille qui elle reste blanche, donc non gravé. Elle gardera alors la couleur d’origine du bois.

Nous avons ensuite exporté notre projet inkscape sur une clé usb puis importé notre logo sur trotec.

Pour les réglages, nous avons fait :

page modèle : nous avons sélectionné les 2 trajectoires puis changé la couleur pour les contours en rouge plus vif car le logiciel ne reconnaissait pas la couche
créer la tâche

page préparée : placement de la forme à l'endroit souhaité sur la plaque de peuplier

Nous avons décidé de le découper dans du contreplaqué de peuplier de 3mm afin de garder un esprit naturel.

Avant l’impression, nous avons réglé avec les flèches de la machine le point de départ du laser ainsi que la hauteur de la plaque.
Voici le résultat de notre impression (à noter que la partie blanche s’enlève).

Nous avons ensuite retiré la partie blanche extérieure pour ne garder uniquement la feuille en contraste.
Nous avons ensuite collé notre logo sur le pot à l’aide de colle Néoprène quoi que nous avons répartis sur les deux faces.

Afin d’avoir un résultat plus propre nous avons retiré l'excédent de colle à l’aide d’un scalpel puis nous avons poncé les résidus de colle.

Phase de découpe laser de la plaque
Nous avons décidé d’ajouter une plaque sur le devant de notre pot afin de rendre notre produit personnalisable. Cette plaque pourra être utilisée par les collaborateurs afin d’écrire leur prénom ou d’indiquer le type de plante.
Comme nous voulions des dessins de plantes sur notre plaque, nous avons décidé de faire le design sur canva, comme pour notre logo.
Voici la première version de notre plaque avec des plantes et nos prénoms en italique.

Nous avons ensuite exporter notre design en png puis importer sur inkscape.
Comme pour le logo, nous avons sélectionné puis vectoriser notre design en cliquant sur chemin > vectoriser.
Malheureusement, nous n’avons pas réussi à faire ressortir les nervures des feuilles une fois notre forme vectoriser. Même en ayant fait des contrastes de couleurs sur canva, la forme ressortait unis une fois vectorisé dans inkscape. Nous avons donc décidé de garder cette forme et de réaliser la plaque tout de même pour voir le rendu.

Pour découper la forme rectangulaire de notre plaque, nous avons placé un rectangle vide à contour rouge à l’aide des formes.

Nous avons ensuite exporté notre projet inkscape sur une clé usb puis importé notre logo sur trotec.-
Nous avons décidé de le découper également dans du contreplaqué de peuplier de 3mm afin de garder une cohérence avec le logo.
Avant l’impression, nous avons réglé avec les flèches de la machine le point de départ du laser ainsi que la hauteur de la plaque.
Voici le résultat de notre gravure :

Nous n'étions pas vraiment satisfaits de cette plaque car la gravure était trop prononcée, ce qui a entraîné des bavures et l’apparition d’ombre.

De plus, nous avons trouvé que les dessins surchargeait le design de notre pot.

Nous avons donc décidé de changer de design et de partir sur un design beaucoup plus sobre.
Une simple plaque en bois sans dessins avec uniquement une gravure de nos prénoms en majuscule. Il fallait donc revenir à la case départ!

Nous avons simplement écrit nos prénoms dans une police simple en majuscule. Puis nous avons tracé un rectangle vide à contour rouge épais afin de délimiter notre plaque.
Nous avons ensuite exporter notre design en png puis importer sur inkscape.
Comme les fois précédentes, nous avons sélectionné puis vectoriser notre design en cliquant sur chemin > vectoriser.
Pour découper la forme rectangulaire de notre plaque, nous avons finalement décidé de placer un rectangle vide à contour rouge à l’aide de l'outil forme directement inkscape.

Nous avons ensuite exporté notre projet inkscape en format svg sur une clé USB puis importé notre logo sur Trotec. Nous avons fait exactement les mêmes réglages que précédemment (pour le logo)
Nous avons encore une fois fais la découpe sur du contreplaqué de peuplier de 3mm.
Avant l’impression, nous avons réglé avec les flèches de la machine le point de départ du laser ainsi que la hauteur de la plaque.
Voici le résultat de notre impression

Comme pour le logo, nous avons collé notre plaque avec de la colle Néoprène.
Résultat visuel du prototype

Plante : Monstera deliciosa
Phase de conception électronique et de codage
Pour mettre en place l'électronique de notre prototype, nous sommes passé par plusieurs phases de test. Le but de ce système est de reconnaitre la présence et l'absence d'eau dans le contenant beige afin de d'allumer ou d'éteindre une LED et, par la suite, de prévenir les collaborateurs de ce besoin d'eau par mail ou par le Slack d'entreprise dans un canal dédié.

La complexité de la transmission de message de nous laissait pas le temps de la réaliser dans le cadre de l'UE. Nous nous sommes donc concentrés sur la reconnaissance de l'eau et l'allumage de la LED en créant un détecteur d'eau DIY. En effet, nous nous sommes mis au défi de réaliser ce montage sans avoir recours à un détecteur d'eau préfabriqué.

À l'aide de Stéphane, nous avons réalisé un premier circuit composé de :

Une Arduino Uno
Un breadboard
Une LED
Un transistor
Trois résistances
Des câbles mâle-mâle

Ce circuit permet d'utiliser deux câbles comme capteurs. En plongeant les deux capteurs dans l'eau, le courant passe entre ces capteurs et allume la LED. Le circuit permet donc d'allumer la LED dès que la présence d'eau est détectée. Ce circuit fonctionne sans code et mais ne permet pas d'éteindre la lampe lorsque de l'eau est détectée.

Les câbles bleus sont les capteurs d'eau que nous immergeons dans l'eau afin de tester le circuit.

Nous nous sommes alors lancés dans des test afin de trouver le code qui nous permettrait d'obtenir le résultat que nous souhaitions. Nous avons essayer différents codes en essayant de changer le circuit pour placer les capteurs d'eau sur les broches A1 et A0 :

// Constantes pour les broches
const int ledPin = 8;
const int cable1Pin = A0;
const int cable2Pin = A1;

// Seuil pour la détection de courant
const int seuil = 100;

void setup() {
 pinMode(ledPin, OUTPUT);
 pinMode(cable1Pin, INPUT);
 pinMode(cable2Pin, INPUT);

 // Initialisation de la LED éteinte
 digitalWrite(ledPin, LOW);
}

void loop() {
 // Mesurer la différence de tension entre les deux câbles
 int tensionDiff = abs(analogRead(cable1Pin) - analogRead(cable2Pin));

 // Si la différence de tension est inférieure au seuil, il n'y a pas de courant
 if (tensionDiff < seuil) {
 digitalWrite(ledPin, HIGH); // Allumer la LED
 } else {
 digitalWrite(ledPin, LOW); // Éteindre la LED
 }

 // Délai pour éviter la surcharge de l'Arduino
 delay(100);
}
Mais la lampe de voulait toujours pas s'allumer...

// Constantes pour les broches
const int ledPin = 8;
const int waterSensorPin = 2;

void setup() {
 pinMode(ledPin, OUTPUT);
 pinMode(waterSensorPin, INPUT_PULLUP);

 // Initialisation de la LED éteinte
 digitalWrite(ledPin, LOW);
}

void loop() {
 // Lire l'état du capteur d'eau
 int waterSensorState = digitalRead(waterSensorPin);

 // Si le capteur d'eau détecte un niveau de tension bas, il n'y a pas de courant
 if (waterSensorState == LOW) {
 digitalWrite(ledPin, HIGH); // Allumer la LED
 } else {
 digitalWrite(ledPin, LOW); // Éteindre la LED
 }

 // Délai pour éviter la surcharge de l'Arduino
 delay(100);
}
int waterSensor1 = A0; // Pin pour le premier détecteur d'humidité
int waterSensor2 = A1; // Pin pour le deuxième détecteur d'humidité
int ledPin = 8; // Pin pour la LED

const int seuil = 500; // Seuil pour la détection d'eau

void setup()
{
 pinMode(waterSensor1, INPUT);
 pinMode(waterSensor2, INPUT);
 pinMode(ledPin, OUTPUT);
}

void loop()
{
 int sensorValue1 = analogRead(waterSensor1);
 int sensorValue2 = analogRead(waterSensor2);
 
 // Si les deux détecteurs d'humidité détectent de l'eau, la LED s'allume
 if (sensorValue1 > seuil && sensorValue2 > seuil)
 {
 digitalWrite(ledPin, HIGH);
 }
 // Si l'un des détecteurs d'humidité ne détecte pas d'eau, la LED s'éteint
 else
 {
 digitalWrite(ledPin, LOW);
 }
 
 delay(1000); // Attendez une seconde avant de répéter
Cependant, les différents codes ne correspondaient pas à notre montage n'arrivaient pas à remplir notre objectif. Après de nombreux essais infructueux, nous avons décidé de re-basculer sur notre premier montage en incluant un code qui permettrait simplement d'allumer ou éteindre une LED en fonction de la présence ou non de courant entre les deux capteurs. Pour cela, il a fallu enlever la LED de notre circuit transistor et la rattacher à une broche de l'arduino afin de la contrôler indépendant sans influence du courant continu. De plus, nous avons installé un câble dans le circuit en A0 afin de détecter la variation des valeurs dans le circuit.

Les câbles bleus sont les capteurs d'eau que nous immergeons dans l'eau afin de tester le circuit.
Il a donc fallu comprendre quels signaux la présence et l'absence d'eau envoyait à l'Arduino (via A0). Pour cela, nous avons utiliser la fonction Serial.print() et nous avons identifié que lorsque l'eau était présente, les valeurs retournées étaient inférieures à 1023 et que lorsque les capteurs étaient immergés dans l'eau la valeur retournées était 1023. Nous avons donc établis le code suivant :

int waterSensor1 = A0; // Pin pour le premier détecteur d'humidité
int ledPin = 8; // Pin pour la LED

void setup()
{
 pinMode(waterSensor1, INPUT);
 pinMode(ledPin, OUTPUT);
 Serial.begin(9600);
}

void loop()
{
 int sensorValue1 = analogRead(waterSensor1);
 Serial.println(sensorValue1);
 //delay(500);
 
 // Si la valeur dans la broche A0 est positive alors on éteint la LED : il y a de l'eau dans le tank
 if (sensorValue1 < 1023)
 {
 digitalWrite(ledPin, LOW);
 Serial.println("Présence d'eau");
 }
 // Si la valeur dans la broche A0 est nulle alors on allume la LED : il n'y a d'eau dans le tank
 else
 {
 digitalWrite(ledPin, HIGH);
 Serial.println("Absence d'eau");
 }
 
 delay(1000); // Attendez une seconde avant de répéter
}
Grâce à ce code nous avons réussi à atteindre notre objectif : lorsque de l'eau est détectée (les deux capteurs sont submergés) la LED est éteinte, lorsque de l'eau manque (au moins l'un des deux capteurs est hors de l'eau) la LED s'allume pour alerter le collaborateur du manque d'eau dans le pot. Les deux capteurs seront placés au niveau de l'extrémité basse du pot dans le réservoir afin de prévenir du manque d'eau dans le substrat. Le breadboard a été remplacé par un mini-breadboard.

Extraits de vidéo
Coût du prototype et structure des revenus/coûts

Impression 3D (PLA) : 2,34 + 6,79 = 9,13€
Découpe laser (Peuplier) : 0,35€
Arduino UNO : 29,40€
Breadboard : 3€
Câbles (14) : 0,89€
Led : 0,02€
Résistances (4) : 0,05€
Batterie : 6,9€
Pot en terre cuite : 0,90 €

TOTAL : 50,64€
En industrialisant les procédés et en faisant appel à de l'achat en gros lots, il est possible de faire drastiquement diminuer les coûts de production.
En vendant le petit module 99,90€ et le modèle plus grand 149,90€, il est possible de faire une marge de plus de 50% ce qui permettra une rentabilité rapide.
Structure des revenus :
Les revenus de GrowTogether proviendront de la vente et de l'installation des murs végétaux dans les entreprises mais également de l'animation des ateliers de plantation et de sensibilisation que nous procurerons à l'instar des nombreuses "fresques".
Structure des coûts variables : 

Impression des pots

Achat des pots en terre cuite

Achat des composants électroniques
Achat du substrat et des plantes/graines
Assemblage des modules
Transports
Installation des murs végétaux chez les clients (jour-Homme)
Intervention de sensibilisation (jour-Homme)

Structure des coûts fixes : 

Frais administratifs
Electricité et consommables

Salaires
Loyers

Canaux et segment client

GrowTogether est un produit destiné aux entreprises. Il sera donc vendu en BtoB directement aux entreprises. Les clients sont donc les Chief Office Manager des différentes entreprises qui cherchent à animer la communauté de collaborateur, les sensibiliser et végétaliser les locaux.

Notre persona :

Identité : Sarah, 40 ans, Chief Office Manager d'un studio d'innovation à impact, Paris
Enjeux : Animer la communauté d'employés et d'entrepreneurs qui résident dans les locaux, permettre de facilement mettre en place des évènements communautaires pour les résidents et de manière fréquente, on-boarder les nouveaux arrivants avec une activité engageante, apporter des connaissances sur la transition écologique et les bon gestes à sa communauté, apporter de la végétation dans les locaux sans avoir besoin de s'en occuper
Besoin : Un solution clé-en-main et facilement déployable sans trop d'organisation et avec un suivi et un entretien facile.

Claire Huang & Servane Pellerin & Soamalala Rajaonarison : Power Grip

Power Grip

Définition du projet
Besoin : Power Grip est un petit gadget portable et pratique qui peut être posé sur une table pour y agripper son sac et charger son téléphone. Il répond à 3 besoins

Conserver un téléphone chargé
Garder un sac propre et à portée de main
Se libérer de ses affaires

Utilisateurs : Le produit est conçu pour les personnes en déplacement et momentanément à une table, qui ont besoin d'une solution pratique pour garder leur téléphone chargé tout en déposant leur sac quelque part.
Fonctionnalité principale : PowerGrip est équipé d'une technologie de charge par induction qui permet de charger facilement les téléphones portables compatibles avec cette technologie.
Fonctionnalités secondaires : Porte-sac
Réflexions sur la problématique et veille sur l'existant

Désir de garder son sac propre et donc d’éviter de le poser au sol dans les restaurants, les bar, le lieux de travail et espaces de coworking mais aussi de l’avoir à vue d’œil pour ne pas se le faire voler.
Nécessité d’avoir un téléphone chargé, notamment en fin de journée, la période la plus propice à être dans un bar ou dans un restaurant.

Produits concurrents : non existants
Produit de substitution :

Sac à dos/main avec chargeur sans fil

WENIG Antivol Sac à Dos Ordinateur Portable 15.6 Pouces Homme Imperméable avec USB Charging Port Sac à Dos d'affaires Sac à Dos Fonctionnel Sac a Dos PC Portable pour Loisirs/Affaire/Scolaire Noir : Amazon.fr: Informatique

marcello Sac à Dos Convient à l'Ordinateur de 15.6 Pouces Elégant Sac à Dos pour Ordinateur Portable Sac Décontracté Imperméable avec USB pour College Voyage Affaires (15,6 Pouces, Gris) : Amazon.fr: Informatique

Nordace Siena Sac à dos intelligent, 19 l, avec port de charge USB, bleu (Bleu) - Siena : Amazon.fr: Mode

KROSER Sac à Dos pour Ordinateur Portable 15.6" Sac à Dos pour Ordinateur Scolaire Élégant avec Port de Chargement USB Sac Imperméable pour Voyage/Affaires/Collège/Femme/Homme Noir : Amazon.fr: Informatique

Support de chargeur sans fil

WILIT Lampe de Chevet Tactile avec Chargeur sans Fil pour Chambre à Coucher, Veilleuse Tactile avec 3 Niveaux de Luminosité : Amazon.fr: Luminaires et Éclairage

Hoidokly Chargeur sans Fil 2 en 1 Chargeur Induction Station de Charge Compatible avec Galaxy S22/S21/S20/Note 20/10, iPhone 14/14 Plus/13/12 Pro/12/11, Galaxy Watch/Active/Buds/Gear 3, AirPods Pro : Amazon.fr: High-Tech

Spigen SteadiBoost Chargeur sans Fil Rapide 15W Certifié Qi Compatible avec 12 Mini 12 Pro Max iPhone SE 2020 11 11 Pro 11 Pro Max XR XS XS Max X 8 8 Plus Galaxy S20 S10 Note 20 Ultra10 et Plus : Amazon.fr: High-Tech

yootech Chargeur sans Fil Rapide, 7,5W pour iPhone 14 13 12 11 Pro Max/SE 2022/XS/XR/8 Plus, AirPods 3/Pro, 10W Max pour Samsung Galaxy S22/S21/S10E/S9/S8,Note 20/10/9/8, Huawei Mate/P30 Pro, Xiaomi : Amazon.fr: High-Tech

Crochet pour sac à main

Flybloom Crochet de sac de sac à main pliable multifonctionnel Crochet de sac pour femme Crochet de table Collection de cintre de table : Amazon.fr: Mode

kwmobile 2X Crochet de Sac à Main - Accroche Sac Pliable en métal - Porte-Sac pour Table ou Bureau Suspension Sac à Main - doré : Amazon.fr: Mode

Lean canvas
Problèmes :

Le déchargement des batteries : les téléphones portables sont devenus un élément essentiel de la vie quotidienne, mais leur batterie a souvent du mal à tenir toute la journée.
La sécurité : mettre son sac par terre ou sur le dossier de sa chaise nous empêche souvent de garder un oeil sur celui ci et de s’assurer qu’il n’est pas volé
L’hygiène : lorsqu’il ne reste plus de place sur une chaise pour poser son sac et qu’il ne tient pas sur le dossier, il n’y a pas d’autres possibilités que de le poser par terre, alors que le sol peut être assez sale
La mobilité : lorsque l’on souhaite garder son sac sous les yeux mais ne pas le poser par terre, il est possible de le garder sur ses genoux mais cela empêche alors d’être libre de ces mouvements.

Public cible : principalement constitué de personnes qui sont souvent en déplacement, comme les étudiants, les professionnels, les personnes actives en général. Il est également adapté aux personnes qui utilisent leur téléphone fréquemment et qui ont besoin d'une charge supplémentaire pour éviter de se retrouver avec une batterie faible en cours de journée.
Proposition de valeur : chargeur par induction avec fonction d'arrêt automatique pour éviter la surchauffe, complété d’un crochet à déplier pour accrocher son sac à une table
Choix techniques

Chargeur à induction : design épuré et moderne, pas de câble à transporter, possibilité de convenir à plusieurs modèles de téléphone, léger et petit

Crochet mobile/pliable : gain de place par rapport à un une tige fixe

Gestion de projet: "minimum viable product", planification et répartition des taches

MVP

Power Grip est un petit gadget portable et pratique à 2 fonctionnalités : porte sac & chargeur à induction pour téléphones.

Rétroplanning / Gantt

Tâches

03/04

04/04

05/04

02/05

Réunion d'équipe

X

Vérification des matériaux pour le MVP

X

Prototype du design de la poignée pour sac à main

X

Conception du plan de fabrication (3D + numérique)

X

Fabrication des prototypes de la poignée

X

Test des prototypes de la poignée pour sac à main

X

Montage des poignées pour sac à main

X

Finalisation du MVP

X

RACI

Tâches

Claire

Servane

Soamalala

Définition du projet

I

I

RA

Réflexions sur la problématique

I

RA

I

Veille sur l'existant

RA

I

I

Lean canvas

I

I

RA

Choix techniques

I

RA

I

Minimum viable product

I

I

RA

Planification et répartition des tâches

R

I

RA

Croquis, dimensions

I

RA

I

Liste du matériel

I

RA

I

Fichiers de conception et étapes de création des fichiers

RA

I

I

Photos et analyse des tests, essais, erreurs

I

I

RA

Photos des étapes de réalisation du Prototype, paramètres des machines

RA

I

I

Photos de l'objet final

I

I

RA

Réflexions de pistes d'amélioration ou d'évolution du projet

R

RA

R

R : Responsible (réalisateur)A : Accountable (approbateur)C : Consulted (consulté)I : Informed (informé)
Croquis, dimensions

Liste du matériel

Du filament plastique
Une imprimante 3D
Une plaque d'expérimentation
Une led
Une plateforme arduino
Deux piles

Des câbles dupont

Fichiers de conception et étapes de création des fichiers

Nous avons réalisé 2 prototypes dont le premier est ci-dessous :

Le deuxième prototype a suivi les mêmes étapes de réalisation sur Tinkercad (https://www.tinkercad.com/things/lTgHbqMT8DC-mighty-uusam/edit?sharecode=gPrPGVCC4Aa3jOVLArQieHRkd-AaASd89fib65j9t3w), en commençant par créer une base ronde qui doit représenter le chargeur par induction et la partie qui sera posée sur la table. Pour cela, nous avons utilisée la forme de disque et lui avons donné les dimensions suivantes :

2cm d'épaisseur ;
8cm de diamètre ;

Nous avons aussi dessiné une petite encoche destinée à représenter le port de chargement USB-C du chargeur.

Par la suite, nous avons dessiné une forme supposée représenter le crochet qui pincera la table et permettra au sac de tenir. Ses dimensions sont les suivantes :

1,5 cm d'épaisseur ;
6,5 cm de hauteur ;
1,5 cm de large entre les 2 lignes parallèles, espace qui correspond à la partie qui "pince" la table.

Nous avons ensuite fusionné cette forme avec le disque initial pour former la structure principale.

Finalement, nous avons dessiné la petite encoche qui dans le cadre de notre prototype, doit permettre d'allumer une led lorsque le téléphone sera posé sur le disque.
Le prototype final ressemble à celui-ci :

Photos et analyse des tests, essais, erreurs
A l'origine, nous comptions pour représenter le chargeur à induction sur notre prototype, utiliser un capteur de distance. Celui-ci devait allumer une led lorsque le téléphone serait posé sur la base ronde pour représenter le chargement, et laisser la led éteinte dans les autres cas. Pour cela, nous avions écrit le code suivant :

const int trigPin = 8;
const int echoPin = 11;
const int LED = 4;

// defines variables
long duration;
int distance;

void setup() {
	pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
 pinMode(echoPin, INPUT); // Sets the echoPin as an Input
 pinMode(LED, OUTPUT);
 Serial.begin(9600); // Starts the serial communication
 }

void loop() {

// Clears the trigPin
	digitalWrite(trigPin, LOW);

 delayMicroseconds(2);

// Sets the trigPin on HIGH state for 10 micro seconds
 	digitalWrite(trigPin, HIGH);
 delayMicroseconds(10);
 digitalWrite(trigPin, LOW);

// Reads the echoPin, returns the sound wave travel time in microseconds
	 duration = pulseIn(echoPin, HIGH);

// Calculating the distance
	distance = duration * 0.034 / 2;

// Prints the distance on the Serial Monitor
	Serial.print("Distance: ");

Serial.println(distance);
 	if (distance <= 250)

{  digitalWrite(LED, HIGH);

	}

else
{
	digitalWrite(LED, LOW);
}

}
On nous a ensuite conseillé de faire quelque chose de plus simple, sans capteur de distance. Nous avons décidé de toujours utiliser une led mais d'utiliser un système de fermeture de circuit lorsque le téléphone est sur la plateforme ronde à l'aide d'une petite languette montrée plus haut dans la partie conception. Avec le poids du téléphone, la languette doit se baisser et permettre la connexion entre 2 plaques de cuivre, ce qui doit fermer le circuit et allumer la led, éteinte lorsqu'il n'y a pas de téléphone.
Photos des étapes de réalisation du prototype, paramètres des machines

En complément de la partie plastique réalisée par impression 3D, nous avons réalisé le circuit avec la led que nous avions prévu, d'abord sans les bandes en cuivre puisque l'impression n'était pas finie, puis avec.

Prix de fabrication
Impression 3D (PLA)Quantité : 82,8g/30,75mPrix total de l'impression : 2,48€Breadboard = 3€Câble = 0,25€ (pour 4)/ 0,19€ (pour 3)Led = 0,02€Scotch de cuivre = 0,05€ (1cm^2)
Prix total du prototype = 5,99€
Photos de l'objet final
Version V0

Version V1 :

Réflexions de pistes d'amélioration ou d'évolution du projet
Plusieurs améliorations sont possible :

Rendre la partie destinée à être le crochet "pliable" pour pouvoir l'entourer autour de la base ronde lorsqu'on la met dans son sac ;
Afficher le pourcentage de batterie restant sur notre produit, peut être à l'aide de petits points lumineux ;
Proposer un système de personnalisation du design sur la surface de la batterie

Roll Up : Marveen Walid Aurélie


Porte papier toilette qui avertit lorsque le rouleau de papier toilette est vide

Définition du projet (besoin, utilisateurs, fonctionnalité principale, fonctionnalités secondaires)

Besoin : savoir lorsque le niveau de papier toilette est faible/nul.
Utilisateurs : barman, en entreprise, manutentionnaire, etc.
Fonctionnalité principale : prévenir lorsque le niveau de papier toilettes est bas/nul afin que le rouleau soit remplacé ; pour un manutentionnaire, savoir quelle quantité de papier toilette apporter lors de son passage aux toilettes.

Réflexions sur la problématique et veille sur l'existant :

Il arrive souvent dans les bars, entreprises ou aires d’autoroute de se retrouver face à un rouleau de papier toilette vide, car les personnes en charge de les changer ne sont pas au courant constamment de l’état du rouleau. De plus, pour les manutentionnaire, lorsqu’ils arrivent avec leur camion, ils ne savent pas quelle quantité de papier toilette apporter avec eux car ils ne savent pas si les rouleaux sont vides ou non - ils se retrouvent donc à porter une charge de produits plus importante que ce qui était nécessaire.
Rollscout : c’est une startup américaine, mais qui a seulement le concept de laser qui détecte sous un certain seuil le manque de papier toilette. Hors, nous souhaiterions ajouter dans le futur un mécanisme permettant de remplacer le rouleau.

Lean canvas

Choix techniques

Électronique numérique pour la détection de présence de papier toilette.
Conception 2D et découpe laser pour le boîtier en bois.
Conception et impression 3D pour la tige sur laquelle sera posé le papier toilette.

Gestion de projet : "Minimum Viable Product", planification et répartition des taches

MVP : tige imprimée en 3D, support fait avec la découpeuse laser, et détecteur laser relié à un ESP 32 qui envoie un signal (Mail ou SMS) quand il n'y a plus de papier toilette.
Planification : Chacun avance sur sa partie pour le 02/05, puis on fait les impressions et les tests le 02/05, et enfin on peaufine et prépare la présentation le 03/05 et le 04/05.
Répartition des tâches :

Marveen : Partie électronique numérique.
Walid : Partie conception et impression 3D de la tige.
Aurélie : Partie conception 2D et découpe laser du boîtier en bois.

Croquis, dimensions

Boîtier pour le capteur : minimum 5*2,2*2,5 cm.
Fente pour le capteur : 1*0,5*1 (profondeur) cm.

Liste du matériel

ESP 32
Câbles pour relier les composants
Capteur de distance
Logiciel Inkscape
Logiciel Tinkercad
Logiciel Arduino
Imprimante 3D
Découpe laser

Partie Électonique Numérique : Circuit et Programmation de l'ESP32

Première étape : Soudure des broches de l'ESP32

Comme les broches du capteur n'étaient pas déjà soudées, nous les avons soudées nous même avec de l'étain.

Deuxième étape : Test du programme Blink

Ce programme consiste à faire clignoter une LED en fonction du délai choisi.
Sur notre circuit, nous avons relié la LED à la broche 14 de l'ESP32.
Voici le code de ce programme :
int LED_BUILTIN = 14;

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

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

Troisième étape : Test du capteur

L'objectif de ce programme est d'allumer la LED (qui a été utilisée dans le programme Blink) lorsque le capteur ne détecte pas de présence, et donc de la conserver éteinte lorsque de la présence est détectée.
Pour cela, nous avons relié notre capteur à la broche 12 de l'ESP32.
Et voici le code que nous avons utilisé pour ce programme :
int Led = 14;
int Capteur = 12;
int val;

void setup() {
 pinMode(Led, OUTPUT);
 pinMode(Capteur, INPUT);
 Serial.begin(9600);
}

void loop() {
 val = digitalRead(Capteur);
 Serial.print("Distance : ");
 Serial.println(val);
 if (val == HIGH)
 {
 digitalWrite(Led, HIGH);
 }
 else {
 digitalWrite(Led, LOW);
 }
}

Et voici le circuit réalisé pour ce programme :

Quatrième étape : Connexion de l'ESP32 à Internet

Pour pouvoir envoyer un mail à partir de l'ESP32, il faut que ce dernier soit connecté à Internet.
Pour cela, nous avons d'abord essayé le code disponible sur Arduino "WiFiManager".

Ce code met l'ESP32 en mode "station", c'est-à-dire qu'il faut connecter son téléphone à l'ESP32 comme si on se connectait à un réseau WiFi quelconque.
Une fois connecté à l'ESP32, il fallait renseigner le nom et le mot de passe du réseau WiFi auquel on voulait que l'ESP32 se connecte.
Enfin, l'ESP32 se connectait au réseau WiFi.
Le problème avec ce programme est que l'on ne peut pas avoir la preuve que l'ESP32 est bien connecté au réseau WiFi.

Nous avons donc utilisé un autre programme, qui fait que l'ESP32 se connecte directement à un réseau WiFi, après avoir renseigné le nom et le mot de passe du réseau WiFi directement dans le code.

Voici le lien que nous avons utilisé pour cela : https://www.upesy.fr/blogs/tutorials/how-to-connect-wifi-acces-point-with-esp32
Et voici le code que nous avons utilisé pour ce programme :
#include <WiFi.h>

const char* ssid = "Marveen";
const char* password = "1234567890";

void setup(){
 Serial.begin(115200);
 delay(1000);

 WiFi.mode(WIFI_STA); //Optional
 WiFi.begin(ssid, password);
 Serial.println("\nConnecting");

 while(WiFi.status() != WL_CONNECTED){
 Serial.print(".");
 delay(100);
 }

 Serial.println("\nConnecté au réseau WiFi");
 Serial.print("Local ESP32 IP: ");
 Serial.println(WiFi.localIP());
}

void loop(){}

De cette manière, nous pouvions voir directement sur le téléphone qui effectue le partage de connexion que l'ESP32 était bien connecté :

Cinquième étape : Faire envoyer un mail par l'ESP32

Pour faire cela, nous avons suivi beaucoup de tutos sur Internet, mais cela était plutôt compliqué, et les codes utilisés comprenaient plus de 200 lignes chacun.
De plus, il fallait créer un nouveau compte Gmail, et autoriser sur ce compte l'envoi par des sources non sécurisées. Cependant, cette fonctionnalité a été arrêtée par Gmail depuis 2022, ce qui rendait donc cette méthode inutilisable.
Enfin, après avoir réfléchi sur le sujet, nous nous sommes rendus compte que l'envoi d'un mail n'est pas optimal, car on regarde beaucoup moins ses mails que ses messages.
L'envoi par mail étant trop complexe et non optimal, nous avons décidé de passer par un envoi de message sur Whatsapp.
Lien utilisé pour cette étape : https://randomnerdtutorials.com/esp32-email-alert-temperature-threshold/

Sixième étape : Faire envoyer un message Whatsapp par l'ESP32

Pour cette étape, nous avons suivi le tutoriel du lien suivant : https://www.raspberryme.com/esp32-envoyer-des-messages-a-whatsapp/#:~:text=Pour%20envoyer%20des%20messages%20%C3%A0,de%20vous%20envoyer%20un%20message
Il fallait tout d'abord créer un BOT sur un compte Whatsapp pour obtenir un "APIKEY", que nous allons utiliser dans notre code.
Il fallait ensuite télécharger la bibliothèque URLEncode.
Nous avons ensuite utilisé le code suivant pour faire envoyer un premier message de test sur Whatsapp par l'ESP32 :
#include <WiFi.h> 
#include <HTTPClient.h>
#include <UrlEncode.h>

const char* ssid = "Marveen";
const char* password = "1234567890";

String phoneNumber = "+33621941918";
String apiKey = "8433739";

void sendMessage(String message){
 String url = "https://api.callmebot.com/whatsapp.php?phone=" + phoneNumber + "&apikey=" + apiKey + "&text=" + urlEncode(message); 
 HTTPClient http;
 http.begin(url);

 http.addHeader("Content-Type", "application/x-www-form-urlencoded");
 
 int httpResponseCode = http.POST(url);
 if (httpResponseCode == 200){
 Serial.print("Message sent successfully");
 }
 else{
 Serial.println("Error sending the message");
 Serial.print("HTTP response code: ");
 Serial.println(httpResponseCode);
 }

 http.end();
}

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

 WiFi.begin(ssid, password);
 Serial.println("Connexion en cours");
 while(WiFi.status() != WL_CONNECTED) {
 delay(500);
 Serial.print(".");
 }
 Serial.println("");
 Serial.print("Connecté au réseau Wi-Fi avec l'adresse IP : ");
 Serial.println(WiFi.localIP());

 sendMessage("Il n'y a plus de papier toilette, il faut en remettre !");
}

void loop() {
}

Septième étape : Création du code final

Après avoir testé toutes les fonctionnalités de manière séparée, il ne reste plus qu'à les intégrer sur le même code.
Nous souhaitons que lorsque le capteur ne détecte plus de présence (donc il n'y a plus de papier toilette), il allume la LED et envoie un message pour prévenir qu'il n'y a plus de papier toilette et qu'il fait en remettre.
Voici le code final pour notre projet :
#include <WiFi.h> 
#include <HTTPClient.h>
#include <UrlEncode.h>

int Led = 14;
int Capteur = 12;
int val;

const char* ssid = "Marveen";
const char* password = "1234567890";

String phoneNumber = "+33621941918";
String apiKey = "8433739";

void sendMessage(String message){
 String url = "https://api.callmebot.com/whatsapp.php?phone=" + phoneNumber + "&apikey=" + apiKey + "&text=" + urlEncode(message); 
 HTTPClient http;
 http.begin(url);

 http.addHeader("Content-Type", "application/x-www-form-urlencoded");
 
 int httpResponseCode = http.POST(url);
 if (httpResponseCode == 200){
 Serial.print("Message sent successfully");
 }
 else{
 Serial.println("Error sending the message");
 Serial.print("HTTP response code: ");
 Serial.println(httpResponseCode);
 }

 http.end();
}

void setup() {
 pinMode(Led, OUTPUT);
 pinMode(Capteur, INPUT);
 
 Serial.begin(115200);

 WiFi.begin(ssid, password);
 Serial.println("Connexion en cours");
 while(WiFi.status() != WL_CONNECTED) {
 delay(500);
 Serial.print(".");
 }
 Serial.println("");
 Serial.print("Connecté au réseau Wi-Fi avec l'adresse IP : ");
 Serial.println(WiFi.localIP());
}

void loop() {
 val = digitalRead(Capteur);
 Serial.print("Distance : ");
 Serial.println(val);
 if (val == HIGH)
 {
 digitalWrite(Led, HIGH);
 sendMessage("Il n'y a plus de papier toilette, il faut en remettre !");
 }
 else {
 digitalWrite(Led, LOW);
 }
}

Huitième étape : Autonomisation du notre circuit

Pour rendre notre circuit autonome, et ne plus avoir besoin de le brancher à un ordinateur, nous l'avons branché à une batterie portable.
Au début, cela ne fonctionnait pas, car il fallait brancher la batterie à la broche "BAT" de l'ESP32, et non "USB" comme c'était le cas avant.
Après avoir fait cette modification de broche, tout a fonctionné correctement, et la démonstration de notre prototype est en pièce jointe.

Partie Conception 2D et Découpe Laser pour le boîtier en bois

Afin de générer une boite avec les bonnes rainures, nous avons générer le code svg permettant de produire notre boîtier sur internet. Pour cela, il a fallu indiquer les dimensions souhaitées et importer directement le fichier svg dans le logiciel Inkscape.

Une fois l’importation réalisée, nous avons donc les patrons de notre boîtier. Nous avons bien vérifié que le fond était non coloré et que les contours étaient bien rouge, car c’est ce qui va indiquer que la machine va découper le long des traits rouges.

Puis, nous avons lancé l’impression, d’abord sur 2 des pièces afin de vérifier que les rainures étaient bien adaptées, puis sur l’ensemble des faces.
Par la suite, comme nous souhaitions avoir le nom de “ROLL UP” sur la face supérieure, nous avons utilisé Inkscape une nouvelle fois, cette fois en utilisant le mode gravure. Pour cela, il a bien fallu penser à mettre le fond de chacune des lettres de couleurs noires.
Nous avons ensuite positionné la face supérieure de notre boîtier dans la machine avant de lancer la gravure (après avoir effectué un test au préalable).

Partie Conception et Impression 3D pour la tige

Reproduction de la boîte & modélisation du support pour papier toilette

Pour cela, nous décidons dans un premier temps de réaliser un bloc plein reprenant les dimensions de la boîte que nous avons designée.
Nous décidons ensuite de réaliser la pièce qui va supporter le papier toilette. Pour cela nous décidons d'utiliser comme base un heptaèdre. Pour s'assurer que le heptaèdre et parfaitement bien placés nous avons décidé d'utiliser un hexaèdre comme élément de référence.
Pour réaliser le support de papier nous utilisons une base cylindrique pour accueillir le papier toilette. Nous réalisons également deux trous pour accueillir les visses.

Réalisation d'un double fond

Pour stocker les différents composants électroniques, nous décidons de créer un double-fond dans notre boîte. Il s'agit d'une simple plaque fine reprenant les dimensions internes de la boite. Pour la fixation de notre plaque, nous utilisons de la colle. Pour notre version finale, nous aimerions avoir une surface rainurée.

Impressions

Fichiers de conception et étapes de création des fichiers (captures d'écran) / code

https://cyberweb.cite-sciences.fr/wiki/doku.php?id=projets:generateur_de_boites : permet de générer la boîte

https://www.becquet.fr/derouleur-papier-toilette-en-bambou-p222419 : inspiration pour le design et donne une idée des dimensions de la structure en bois : L.18*l.10*H.14 cm
https://www.cdiscount.com/bricolage/sanitaire-salle-de-bain/porte-rouleau-papier-toilettes-asofty-derouleur-p/f-1661005-ann4811630277986.html : pour être certain des dimensions, et on voit qu’on va plutôt être sur du L.18*l.10*H.7 cm
Les codes sont directement ajoutés dans la partie Électronique Numérique.
Les fichiers de nos conceptions sont en pièces jointes.

Photos et analyse des tests, essais, erreurs

Lors de la première impression de la tige, celle-ci était trop courte. Il a donc fallu la modéliser une seconde fois avec des dimensions plus adaptées. Voici la photo de la première tige :
Les erreurs rencontrées au niveau des codes sont directement dans la partie Électronique Numérique.

Photos de l'objet final

Réflexions de pistes d'amélioration ou d'évolution du projet :

Personnalisation possible du matériau et du logo
Adaptation à différents formats de rouleaux

Système d’échange de rouleau lorsqu’un des deux est vide

KHADA - fine tableware [Adrien, Mouna, Hatice]


Le projet KHADA propose de la vaisselle de table de luxe 
pour les particuliers et professionnels du domaine du luxe, de l'hôtellerie et de la restauration.

📑 I/ Le projet

    💬 A - Besoins et problématique

> Les tendances et les goûts des consommateurs évoluent.

> Les phénomènes de mode influencent le consommateur selon les saisons.

> Les consommateurs tendent vers une consommation plus durable et accordent plus d'attention à leur impact environnemental.
> Le minimalisme, ou la volonté de ne posséder que l'essentiel, est  un mouvement en vogue.
> Que cela soit chez un professionnel ou un particulier, les espaces de rangement sont limités.
=> Story-telling : l'idée nous est venue alors que nous étions tous les trois en plein déménagement. D'une part, nous avons réalisé que nous possédons beaucoup de vaisselle ce qui n'est pas pratique. D'autre part, nous apprécions quand même acheter de la nouvelle vaisselle si son design est beau afin de varier la décoration de nos tables. Et ce, même si elle nous encombre plus.

 💡 B - L'offre

1) Le produit et sa valeur ajoutée
ASSIETTE
> Pour répondre à ces différentes problématiques, nous avons pensé à développer le produit suivant :

 

Images générées par l'IA DALL-E avec la phrase "assiette carrée digitale"
> En apparence, l'assiette n'aura effectivement pas beaucoup de différences par rapport à une assiette classique. Cependant, la particularité résidera dans le fait de pouvoir changer le design de sa vaisselle sans devoir acheter plusieurs sets. Il saura même possible d'opter pour des designs animés. A ce sujet, certains restaurant proposent déjà du video mapping sur leurs tables pour offrir une expérience unique à leurs clients.
TABLETTE
> Pour pouvoir changer les designs des assiettes, l'utilisateur aura à sa disposition une tablette fournie avec l'achat de la vaisselle. Ainsi, cela invitera de télécharger une application sur le smartphone de toutes les personnes qui seront amenées à utiliser cette vaisselle.

 
Images retrouvées sur Google Images, et nos plus grandes sources d'inspiration
COUVERTS
> Nous avons également pensé à vendre des couverts dont le manche serait amovible et personnalisable, composé d'un liquide spécial qui brille lorsqu'on le secoue. Cela est un peu à l'image des boules à neige.
POSITIONNEMENT
> Le premier objectif sera de proposer de l’art de table haute gamme avec un design avant-gardiste. C'est pour cela que nous avons fait le choix de devoir utiliser une tablette. Le positionnement de notre marque se veut être élevé.

> Le second consiste à susciter un effet waouh chez le consommateur.
2) La cible
> Les fine restaurants (hôtels ou indépendants) et les maisons de luxe
> Les particuliers de la haute catégorie socio-professionnelle
> Les évènements de luxe/artistiques/culturels
3) Plus concrètement
Voici quelques réponses aux questions qui pourraient être soulevées par un tel produit :

> L'assiette sera-t-elle assez étanche pour passer au lavage ? Totalement, le verre autour de l'écran sera soudé de façon à être hermétique à l'eau.
> Comment recharger l'écran de l'assiette lorsque celui-ci n'aura plus de batterie ? La recharge se fera tout simplement par induction en posant l'assiette sur son support approprié.
> Comment notre marque sera-t-elle rentable si nous ne vendons qu'une seule fois nos produits ? En plus de la vente (ou location), nous pourrons faire des bénéfices sur la réparation des produits lorsque ceux-ci s'abiment, la vente et la conception des designs uniques sur la boutique en ligne ou encore le développement de la gamme avec le temps (nouvelles assiettes, bols, saladiers, plateaux, présentoirs, verres, accessoires décoratifs de table et d'intérieur, etc).

    📍C - Positionnement et marché

1) Prix

> Nous proposons un lot de 36 pièces comprenant de la vaisselle de différentes dimensions et la tablette pour sélectionner le design à 2500 euros.

2) Concurrence
> Au niveau de la concurrence, seule une start-up, Eatense, s'est lancée dans la production d'assiettes rectangulaires basée sur le même principe en 2018. Toutefois, cette marque vise un marché plus global comme les particuliers et se veut donc être accessible (design modifiable via nos smartphones) avec un prix inférieur (env 150 €).

 
Images retrouvées sur Google Images
> Tandis que KHADA vise un marché plutôt BtoB dans le domaine du service et de la restauration et le BtoC pour une catégorie socio-professionnelle plus aisée.

> Parmi les autres concurrents indirects, nous pouvons citer toutes les marques d'arts de table qu'il existe actuellement sur le marché mais elles ne répondent pas aux mêmes problématiques que nous.
💻 II/ La théorie
⚙️ A - Choix des composantes techniques

> Rappelons la définition d'un Minimum Viable Product (MVP). Il s'agit d'une version fonctionnelle et élémentaire du produit.
> Pour notre MVP, par soucis de complexité et de manque de temps/moyens à disposition, nous avons donc décidé de concevoir une assiette dont le design serait changé par des feuilles de papier au lieu d'un écran. Nous opterons pour les techniques :

D'impression 3D : pour la base de l'assiette, la tête de la fourchette ainsi que le bouchon du manche

De découpe laser : pour le haut transparent de l'assiette
Un petit circuit électronique avec des LEDS : pour simuler un écran en illuminant l'intérieur de l'assiette, faute d'avoir un réel écran. => idée donnée par nos encadrants

🗒️ B - Quelques croquis
1) L'assiette
Tout d'abord, voici les premières esquisses de l'assiette :

> Nous souhaitions imprimer en 3D un boîtier sans couvercle (avec un côté vide pour insérer la feuille de papier) de forme carrée de 25x25 cm et d'une hauteur de 2 cm pour mettre de la marge pour la bande de LED qui mesure 1.5 cm d'épaisseur.
> Nous pensions ensuite découper avec le laser une planche transparente de PVC que nous collerions dessus.
> Les dimensions ont été choisies pour calquer avec la réalité.

> Ainsi, nous avons fait le design sur Thinkercad (avec un bloc puis fonction perçage):

 
2) La fourchette

Voici le premier croquis de la fourchette :
> Pour prototyper les couverts, nous avons imaginé une fourchette donc le manche serait un morceau de tuyau rempli d'un liquide coloré pailleté/marbré pour mimer l'effet visuel que le produit final aurait.
> Le haut de la fourchette serait fait d'un matériau différent et un bouchon relierait les deux parties.

> Pour ce faire, nous souhaitions utiliser un morceau de tuyau retrouvé dans le Fablab pour la base et imprimer les deux autres éléments en 3D. Nous les avons modélisés sur Thinkercad :
 
> Pour le haut de la fourchette, nous avions d'abord eu l'ambition de la dessiner nous même sur Inkscape :

> Puis, nous avons réalisé qu'il serait préférable d'importer une image de Google, de la vectoriser et de l'imprimer. Le rendu serait plus rapide, joli et efficace :
   

 

 

 

 

 

 

 

Avant vectorisation                                                       Après vectorisation

📒 C - Liste de matériel V1
> Voici tout le matériel nécessaire à notre prototype avec les dimensions et les références :

tuyau de 8 cm
filament pour l'impression 3D
plaque dorée pour la découpe laser
plaque plexi transparente pour la découpe laser
20 cm de LED
circuit pour le LED
papier coloré et designs divers imprimés
colle
ciseaux
eau + colorants alimentaire/peinture + paillette/vernis à ongles
les fichiers sur clé USB pour lancer les impressions/découpes gravures

🛠️ III/ L'expérimentation

🗓️ A - L'organisation du projet

> Cela fut très compliqué de trouver une organisation alliant notre alternance entreprise/université, nos horaires de travail et celles d'ouverture du Fablab.

> Pour ce faire, nous avons créé un groupe Whatsapp et nous avons établi un planning fixant les jalons nécessaires à l'avancée, de notre projet (de la conception du prototype à la préparation de notre présentation finale).

Lundi
Mardi
Mercredi
Jeudi
Vendredi
Samedi
Dimanche

03 - J1
Idéation : brainstorming de l'idée

Création d'esquisse et conception 3D

04 -J2
Adrien nous rejoint
Observation des matériaux que nous pouvons utiliser, réitération de la conception/impression du prototype

05 - Lancement de des impression 3D et découpe laser + assemblage
06 - Repartir au Fablab si nécessaire
07
08

09 - deadline
Elaboration de la partie stratégie marketing, business et industrialisation

10
11
12
13
14
15

16 - deadline/meeting visio
Préparation des designs test

17
18
19
20
21
22
23

24
25
26
27

28 - deadline
Finir le wiki et le diapo

29

30 - réunion
S'entrainer pour l'oral

01
02 : ORAL

🎯 B - Résultats
> Dans la pratique, voici comment s'est déroulé notre projet ...

Visualisons ensemble nos péripéties.
1) Impressions 3D

> Le mercredi 05 avril, nous avons lancé une première impression 3D. Cependant, elle n'a pas fonctionné et malheureusement nous n'avons pas pu en connaître les raisons car les encadrants avaient déjà tout rangé. Ainsi, le 02 mai, nous avons lancé une seconde impression 3D.

=> Modification de l'assiette : Nous avons opté pour la version avec les 4 bord couverts (et non plus 3) en pensant que ce serait plus pratique pour cacher les fils du circuit électronique.
> Voici les différentes étapes pour imprimer en 3D, illustrées par les photographies ci-dessous :

Importer les fichiers sur le logiciel de l'imprimante de l'ordinateur de la salle d'impression.
Vérifier la bonne disposition des éléments sur la plaque de l'imprimante.

Régler les paramètres (densité, matériau, etc).

Transférer sur une imprimante disponible.

Lancer l'impression.

 

 
A noter : nous souhaitions lancer l'impression des trois éléments sur la même imprimante mais le logiciel ne pouvait pas le faire. De ce fait, nous avons lancé deux impressions : une avec le haut de la fourchette et une autre pour le bouchon et le manche.

> Malheureusement, les impressions ont encore échoué. Seul le haut de la fourchette a bien été imprimé.

Nous avons donc décidé d'improviser en bricolant notre produit.

2) Découpe laser et gravure du logo
> Puisqu'il était impossible en terme de timing de relancer une impression 3D, nous avons décidé d'utiliser la plaque correspondant à la base de l'assiette qui était déjà imprimée. Ainsi, du matériel et du temps seraient économisés.

> Nous avons donc décidé d'imprimer 4 bandes rectangulaires sur une plaque miroir et ainsi graver notre logo sur les côtés.
> Pour cela, nous désignons ces éléments depuis le logiciel Trotec.         

Quant au logo, nous l'avions précédemment réalisé sur Canva puis vectoriel sur Inkscape.
> Tout d'abord, nous avons réalisé un test sur un morceau qui nous servira par la suite pour notre fourchette (nous ne gâchons rien !).
 
> Nous validons la découpe et la gravure !
 
3) Circuit électronique
> Pour le circuit électronique, nous avons programmé un circuit de LED de 9 diodes avec un effet arc-en ciel pour pouvoir tester le PoC sans utiliser plus de matériel que prévu.

> Le branchement Arduino n'est pas la partie la plus compliquée. Il nécessite :

Une Carte Arduino UNO R3
3 fils Mâle vers Mâle
Un ruban LED NeoPixel de 9 diodes.

> Maintenant, il reste à produire le code pour permettre l'éclairage l'aide à l'aide de la bibliothèque Adafruit_NeoPixel.
CODE
#include <Adafruit_NeoPixel.h>
> Ceci est une bibliothèque spéciale utilisée pour contrôler les pixels NeoPixel. Elle doit être installée à partir du gestionnaire de bibliothèques Arduino.
#define PIN 2
#define NUMPIXELS 9 
> Ces deux lignes définissent les constantes pour le code. PIN est le numéro de la broche sur laquelle la bande de LED est connectée (broche 2 dans ce cas) et NUMPIXELS est le nombre total de LEDs sur la bande (9 dans ce cas).
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
> Ici, nous créons un objet pixels qui est une instance de la classe Adafruit_NeoPixel. Cet objet nous permettra de contrôler la bande de LED. Les paramètres de ce constructeur sont le nombre de pixels, le numéro de la broche à laquelle ils sont connectés, et le type de bande de LED.
int delayval = 100; 
> C'est le délai entre le changement de couleur de chaque LED (en millisecondes).
int redColor = 0;
int greenColor = 0;
int blueColor = 0;
> Ces trois variables contiennent les valeurs actuelles pour les couleurs rouge, verte et bleue. Elles seront modifiées plus tard dans le code.
void setup() {
 pixels.begin();
 Serial.begin(9600);
}
> La fonction setup() est appelée une fois au démarrage. pixels.begin() initialise la bande de LED et Serial.begin(9600) initialise la communication série à un débit de 9600 bauds.
void loop() {
 setColor();

 for(int i=0;i<NUMPIXELS;i++){
 pixels.setPixelColor(i, pixels.Color(redColor, greenColor, blueColor));
 pixels.show();
 delay(delayval); 
 if (i == NUMPIXELS){
 i = 0;
 setColor();
 }
 }
}
> La fonction loop() est appelée en boucle après setup(). Elle commence par appeler setColor() qui choisit une nouvelle couleur aléatoire. Ensuite, elle parcourt chaque pixel de la bande, change sa couleur et affiche le résultat. Ensuite, elle attend pendant delayval millisecondes avant de passer à la LED suivante. Une fois qu'elle a parcouru toutes les LEDs, elle recommence à zéro.
void setColor(){
 redColor = random(0, 255);
 greenColor = random(0,255);
 blueColor = random(0, 255);
 Serial.print("red: ");
 Serial.println(redColor);
 Serial.print("green: ");
 Serial.println(greenColor);
 Serial.print("blue: ");
 Serial.println(blueColor);
}
> Enfin, la fonction setColor() génère une couleur aléatoire en choisissant une valeur aléatoire pour le rouge, le vert et le bleu. Ensuite, elle imprime ces valeurs sur le port série. Ceci peut être utile pour le débogage ou simplement pour savoir quelle couleur est actuellement affichée.

SOUDURE
> L'utilisation d'une bande NeoPixel ne permet pas de simples Plug&Play. Il faut donc souder nos fils à la bande de pixels.

> Pour cela, un atelier soudure s'impose en suivant les étapes suivantes :

Chauffer le soudeur à hauteur de 250°C.
Elonger les 3 fils en laissant 3cm de découvert.
Souder le 5V sur le 5V, le GND sur le GND et le pin 2 sur le Din.Attention à bien prendre la bande LED par le Din et pas le Dout. Le Dout sert à connecter la bande en sortie.
Penser à bien recouvrir les fils dénudés avec l'étain.

📦 C - Le produit final
> Avec les éléments que nous avons à disposition, nous passons à l'assemblage avec les moyens de bord.
 

> A nouveau, nous avons quelques imprévus :

Pas de paillettes ni de vernis à ongles pailleté à disposition (petit problème logistique) : nous essayons alors avec du fard à paupière pailleté et de la peinture acrylique ainsi que du gel nettoyant visage (plus visqueux donc moins de risque qu'avec de l'eau).
La colle forte japonaise ne tient pas le plastique et la plaque miroir -> nous utilisons alors le pistolet à colle (qui fait des dégâts laids mais au moins cela colle)
Nos designs imprimés sur papier A4 qui sont trop petits pour notre assiette de 25cm de largeur.

> Résultat final :
 

Nous avons estimé le coût de revient de ce prototype V1 :

- Base de l'assiette : 3 euros (estimé par l'imprimante 3D)
- Haut de la fourchette : 33 cts (estimé par l'imprimante 3D)
- Bordure miroir : 4 euros

- Arduino : 4,5 euros

- Fils électriques + LEDs : 1 euro
- Composants restants : 1 euro
=> TOTAL : 13,83 euros
💭 IV/ Perspectives d'amélioration et évolution
> Voici quelques pistes d'amélioration et réflexions pour notre projet.
✖️ A - Réglementation
> Il est important de se renseigner sur la réglementation en vigueur dans le secteur de commercialisation de notre produit. Dans notre situation, il s'agit d'un produit qui sera directement en contact avec des produits alimentaires. La législation sanitaire est donc stricte à ce sujet. 

> Les articles ci-dessous regroupent les principales exigences concernant notre produit :

https://www.economie.gouv.fr/dgccrf/Fiche-generale-relative-a-la-reglementation-des-ma
https://www.contactalimentaire.fr/fr/normes-referentiels-contact-alimentaire

♻️ B - Économie circulaire
> Notre objectif est de s'inscrire en tant qu'entreprise éco-responsable sur notre marché. Nous mettons un point d'honneur à nous impliquer dans une démarche plus durable avec une économie circulaire. Rappelons que celle-ci consiste à produire des biens et des services de manière durable en limitant la consommation et le gaspillage des ressources et la production des déchets.
> Notre produit nécessité l'utilisation d'écrans dont la production et la conservation impliquent une empreinte carbone élevée. Nous souhaitons donc, d'une part, utiliser des écrans de tablettes et ordinateurs recyclés pour notre produit et d'autre part, recycler les nôtres. De plus, les couverts seraient également faits en plastique ou verre recyclés.
⏱️ C - Et ensuite ?

> Pour accroître notre développement, nous avons pensé à collaborer avec des artistes et graphistes pour proposer des gammes uniques. Ainsi, certaines marques pourraient avoir des designs à leur effigie.
Exemples :

Diner de lancement d'une nouvelle collection d'une marque de haute couture
Réception mariage dans un hôtel
Rassemblement d'associations dans la lutte contre le cancer

> Concernant la chaîne de distribution, de production et de réparation, nous allons faire appel à un prestataire tel que ESQUISSE afin d'être accompagnés par des experts du milieu. En effet, il faut s'assurer de respecter la réglementation en matière de remplacement de pièces usagées, d'échange ou encore de réparation. Pour la distribution, nous devons nous assurer que notre produit sera facilement reproductible à grande échelle. INARI : Cécile DIEVAL, Ann-Rachel NGAMBI, et Nathacha SUBAKARNAN

Projet INARI
Variété - Gain de place - Praticité - Effet de surprise
INARI, le tableau connecté qui permet de changer d'ambiance au cours de la journée !

Logo INARI (source : Canva) :
 
Le mot INARI fait référence au renard d'INARI, très réputé dans la culture japonaise pour sa ruse et son intelligence.

1. définition du projet
a. besoin
Lassitude et désir de changement peuvent survenir après un certain temps. En utilisant un cadre connecté, cela ne pose aucun souci : l'image affichée sur le tableau change automatiquement et s'éteint lorsque personne n'est pas présente dans la pièce.

La décoration intérieur est un secteur prometteur. Chaque année, environ 1,3 million de logements sont vendus, offrant ainsi de nombreuses opportunités pour repenser et renouveler la décoration de sa maison ; et 46 % des acheteurs de produits de décoration renouvellent au moins une fois par an des éléments de leur pièce à vivre. De plus, plus de la moitié des Français achètent des produits de décoration plusieurs fois par an, et plus de 10 % d'entre eux achètent des produits de décoration tous les mois. Parmi les produits de décoration les plus achetés, on trouve des objets tels que des miroirs, des cadres, ...                                De plus, les Français dépensent une part importante de leur budget pour l’ameublement de leur maison, c'est le premier poste de dépense, 44 %.

Par ailleurs, il peut y avoir d'autres raisons pour lesquelles une personne peut vouloir avoir un tableau qui change d'image :

- Ambiance : un tableau qui change d'image peut aider à créer une ambiance particulière dans une pièce en fonction de la couleur générale choisie. Par exemple, des couleurs chaudes comme le rouge, l'orange et le jaune peuvent créer une atmosphère chaleureuse et accueillante, tandis que des couleurs plus fraîches comme le bleu et le vert peuvent créer une atmosphère plus calme et relaxante.
- Décoration : un tableau qui change d'image peut être utilisé comme élément de décoration pour ajouter de la couleur et de l'intérêt visuel à une pièce.
- Humour : pour le plaisir et l'amusement.
- Fonctionnalité : le changement d'image comme un indicateur de température ou comme une horloge de changement d'heure.

De plus, un cadre photo qui change d'images est pratique, car il vous permet de changer facilement les photos affichées sans avoir besoin de faire de travaux supplémentaires : retirer le cadre du mur ou de le manipuler.
b. utilisateurs

Nos utilisateurs cible sont, en B2C, les adultes actifs de 25 à 44 ans.
c. fonctionnalité principale

Un tableau qui change d'image tout au long de la journée, avec sa banque d'image utilisateur personnelle. L'écran s'éteint lorsqu'il n'y a personne dans la pièce et fonctionne en basse énergie. Il s'adapte également à la luminosité ambiante pour un effet le plus réaliste possible.

d. fonctionnalités secondaires

Un tableau qui change d'image tout au long de la journée, via une base de données préchargé de 30 000 tableaux.
2. problématique et concurrence
a. réflexions sur la problématique
INARI est un tableau qui : 
- satisfait tous les goûts : art contemporain, moderne, ancien, ...
- "empêche" le rachat sans cesse de nouveaux tableaux

- est peu consommateur en énergie, car son éclairage est fait à base de LED
La consommation d’une ampoule LED
Quelques chiffres :

- le marché de la décoration d'intérieur représente 13,2 milliards €
- les classes moyenne investissent désormais dans la décoration intérieur
- les français dépensent 532 € pour leur décoration intérieure hors ameublement
- les 25-44 ans est la tranche d'âge qui achètent le plus de décoration

Décoration : les 11 chiffres à retenir sur ce marché en plein boom
b. veille sur l'existant

En matière de ventes :

- la part du secteur du meuble et de la décoration sur Internet continue de croître, représentant désormais plus de 10 % du marché (Amazon 34,6 %, Ikea 21,6 % et Cdiscount 19,9 %).
- plus de la moitié des consommateurs de décoration utilisent le réseau social Pinterest pour planifier leurs achats (bien devant Instagram ou Facebook).

En matière de concurrents direct, nous avons (classé du plus chère au moins chère) :

- Meural par Netgear
Son prix : 699,99 €
Sa fonction : un tableau qui change d'image, soit avec des images personnel ou œuvres avec un banque de données d'images
Son écran : écran LCD
Son affichage : full HD

- Samsung TV the Frame
Son prix : 499 €
Sa fonction : un tableau et TV combiné. Le cadre photo un tableau qui change d'image, soit avec des images personnel ou œuvres avec un banque de données d'images, qui s'éteint lorsque vous êtes parti grâce à un capteur de mouvement
Son écran : écran QLED

Son affichage : full LED
- Lenovo Smart Frame
Son prix : 387,55 €
Sa fonction : un tableau qui change d'image avec des images personnel
Son écran : écran IPS
Son affichage : full HD

- Amazon Echo Show 15
Son prix : 289,99 € (mais plus petite taille que les concurrents)

Sa fonction : un tableau qui change d'image avec des images personnel et qui permet d'organiser son quotidien
Son écran : écran LCD
Son affichage : full HD
En matière de concurrents indirect, nous avons :

- Art Design Story
Son prix : 1 250 €
Sa fonction : un tableau historique (événement sportif, œuvre de maîtres,...) qui regroupe des émotions et les souvenirs sportifs les plus marquants. L'utilisateurs a besoin de scanner des points du tableau pour connaître ces détails.

Son écran : pas d'infos
Son affichage : pas d'infos
La grande famille d'écran LCD : QLED, IPS,...
3. lean canvas

Pour le pricing nous avons choisi notre prix en rapport au cout de revient ainsi qu'en rapport avec la conccurence. INARI coutera donc entre 199,90€ à 499,90€ pour un tableau de 32" à 50". Nous proposons également un service de location à 9,99 € par mois permettant d'avoir accès à plus de 30 000 œuvres.

Détails sur nos KPIs : 
Les indicateurs clés de performance (KPIs) sont des mesures quantitatives qui permettent de suivre la performance d'une entreprise. Voici nos indicateurs clés de performance que l'on peut utiliser pour mesurer les actions de notre start-up :

Chiffre d'affaires : Le chiffre d'affaires est l'un des indicateurs clés de performance les plus importants pour mesurer la réussite financière d'une entreprise. Il mesure le montant total des ventes de l'entreprise sur une période donnée.

Marge bénéficiaire : La marge bénéficiaire mesure la rentabilité de l'entreprise en comparant le montant des bénéfices nets réalisés sur une période donnée avec le chiffre d'affaires de cette même période. C'est un indicateur clé de performance important pour les entreprises qui souhaitent mesurer leur rentabilité.

Coût d'acquisition client (CAC) : Le coût d'acquisition client mesure le montant dépensé par l'entreprise pour acquérir un nouveau client. C'est un indicateur clé de performance important pour les entreprises qui cherchent à mesurer l'efficacité de leurs campagnes marketing.

Taux de conversion : Le taux de conversion mesure le pourcentage de visiteurs du site web de l'entreprise qui effectuent une action souhaitée, comme l'achat d'un produit ou la souscription à un service. C'est un indicateur clé de performance important pour les entreprises qui cherchent à mesurer l'efficacité de leur site web.

Taux de rétention client : Le taux de rétention client mesure la capacité de l'entreprise à conserver ses clients existants sur une période donnée. C'est un indicateur clé de performance important pour les entreprises qui cherchent à mesurer leur capacité à fidéliser leur clientèle.

4. choix techniques
Dans ce projet, nous nous sommes limité et nous avons choisi des matériaux à disposition dans le FabLab, des matériaux simple et facile à trouver
5. gestion de projet
Nous avons décidé de segmenté le projet en cinq phases (dans l'ordre chronologique de nos tâches à effectuer) :

Cadrage - Conception - Réalisation - Clôture - Documentation
Dans ce projet, seul la tâche documentation peut se faire indépendamment des autres, sinon il faut attendre que la tâche d'avant soit terminé afin de commencer la suivante
JALON 0 : tâche cadrage
Début de la tâche : 03/04 début matin
Fin de la tâche : 03/04 fin matin
- Idéation > Tous
Méthode Brainstorming
- Dessin d'un croquis sur un tableau > Tous
JALON 1 : tâche conception 
Début de la tâche : 03/04 aprem
Fin de la tâche : 03/04 soir

- Electronique-circuit (Tinkercad) > Cécile

- Electronique-code (Arduino) > Ann-Rachel/Cécile
- Logo tableau INARI (Inskape) > Ann-Rachel/Nathacha
- Traitement de l'image (Photoshop) > Ann-Rachel
- Cadres tableau INARI (Trotec) > Nathacha
- Boîte 2D pour cacher l'électronique à l'intérieur (Boxes.py) > Ann-Rachel/Nathacha
Une fois la conception fini, on passe à l'impression et aux tests.

JALON 2 : tâche réalisation
découpe Laser
Début de la tâche : 04/04 matin
Fin de la tâche : 04/04 matin

- Cadres tableau INARI > Ann-Rachel/Nathacha/Cécile

- Gravure logo > Nathacha
- Carrées pour faire 1 cm de largeur et 1,5 cm de hauteur > Ann-Rachel/Nathacha
- Boîte 2D > Ann-Rachel/Nathacha
électronique
Début de la tâche : 02/05 début matin
Fin de la tâche : 02/05 fin matin
- Réalisation et test circuit électronique > Ann-Rachel/Cécile

- Soudure de deux ruban LED entre eux > Nathacha
JALON 3 : tâche clôture
Début de la tâche : 02/05 début aprem
Fin de la tâche : 02/05 fin aprem
- Assemblage de l'ensemble > Tous

JALON 4 : tâche documentation 
Début de la tâche : 03/04 matin
Fin de la tâche : 04/05 aprem

Tout au long du projet
- Page Wiki FabLab > Cécile

Si vous souhaitez exécuter notre projet ; vous pouvez pour plus de précisions utiliser le diagramme Gantt comme planificateur de projet ou la matrice RACI (nous n'avions pas besoin de ces outils de gestion car nos tâches était rapide et fait dans la journée sur des jours clés)
6. croquis

7. liste du matériel avec dimensions
a. conception 2D (du fond du tableau au devant du tableau)
- Liège (fond du tableau) : 20 cm de largeur et 25 cm de hauteur (dont logo de marque : mettre les dimensions)
- Vinyle de couleur noir : 15 cm de largeur et 25 cm de hauteur

- Plexiglas : 20 cm de largeur et 25 cm de hauteur, avec gravure au centre : 10 cm de largeur 15 cm de hauteur
- Bois : 20 cm de largeur, 25 cm de hauteur et 3mm d'épaisseur avec ouverture au centre : 10 cm de largeur 15 cm de hauteur (dont logo renard INARI gravé : 3 cm de hauteur et 3 cm de largeur) + 8 rectangles de 1 x 1,5 x 0,6cm
- Acrylique : 20 cm de largeur et 25 cm de hauteur avec ouverture au centre : 16 cm de largeur et 21 cm de hauteur

- Boîte 2D en Wood Cork 3mm : 19 cm de longueur, 13 cm de largeur et 10 cm de hauteur avec ouverture au centre : sur la face avant 3 x 5 cm, 3 x 3 cm sur la face gauche et un de 3 x 3 sur la face du haut qu'on a du agrandir en 3 x 6 cm, pour que les fils puissent passer
Prix : 10 €
b. électronique
- Capteur HC-SR04 (de distance)
- Carte Arduino
- Fils

- Appareil de soudure

- Ruban LED ws2812b : 20 cm

Prix : 40 €
Prix total tableau : 80 € (50 € prix de construction du tableau et 30 € pour la main-oeuvre, gestion publicité, ...)
c. assemblage
- Pistolet à colle chaude

- Ruban double face
- Colle à bois

- Colle néoprène
8. photos des étapes de réalisation du prototype
a. partie découpe laser tableau

- Image tableau INARI via le logiciel Trotec
Premier test de petite taille :

1. Conception

2. Impression

3. Sortie de l'imprimante

Faire attention à bien placer le point en haut à gauche et attendre que la machine laser ne fasse plus de bruit pour sortir son impression sous risque de se faire brûler
Nous nous sommes rendu compte que notre image était trop négatif, donc flou, nous utiliserons le mode négatif léger pour notre "vrai impression"
Image du tableau INARI traitée (source : Kelogsloops) :

- Cadres tableau INARI via le logiciel Trotec
Même démarche que image tableau INARI
Résultat image et cadre tableau :

- Gravure logo via la logiciel Inskape

Même démarche que image tableau INARI
- Carrés de support  x 2 (1 cm de largeur et 1,5 cm de hauteur) via le logiciel Trotec
1. Impression

2. Assemblage avec colle de bois

3. Création épaisseur du tableau afin de faire passer la LED plus tardivement

b. partie électronique

- Simulation du circuit électronique via le logiciel Tinkercad
Image du montage pour ruban de 6 LED :

Pour exécuter le code : Installer Arduino, télécharger la bibliothèque Adafruit neopixel et chercher le code approprié (dans file > example). Brancher le fils noir sur ground et le rouge sur 5 volt, for pour définir le nombre de LED et GRB pour la couleur de la LED.
Code pour ruban de 6 LED :

#include <Adafruit_NeoPixel.h>
// Define the LED strip parameters#define NUM_LEDS 6 // nous avons 6 LED sur le ruban #define LED_PIN 13 // le ruban de LED est branché sur la PIN 13
Adafruit_NeoPixel strip(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);
// Define the HC-SR04 parameters#define TRIGGER_PIN 9#define ECHO_PIN 10
long duration;int distance;
void setup() {  // Start the serial communication  Serial.begin(9600);

 // Initialize the LED strip  strip.begin();  strip.show(); // Initialize all pixels to 'off'

 // Initialize the HC-SR04  pinMode(TRIGGER_PIN, OUTPUT);  pinMode(ECHO_PIN, INPUT);}
void loop() {  // Trigger a pulse to the HC-SR04  digitalWrite(TRIGGER_PIN, LOW);  delayMicroseconds(2);  digitalWrite(TRIGGER_PIN, HIGH);  delayMicroseconds(10);  digitalWrite(TRIGGER_PIN, LOW);

 // Measure the duration of the pulse  duration = pulseIn(ECHO_PIN, HIGH);

 // Calculate the distance  distance = duration * 0.034 / 2;

 // Print the distance to the serial monitor  Serial.print("Distance: ");  Serial.print(distance);  Serial.println(" cm");

 // Update the LED strip  if (distance <= 30) { // le ruban LED s'allume si on se place à une distance inférieur ou supérieur à 30 mètres devant le tableau

   for (int i = 0; i < NUM_LEDS; i++) {      strip.setPixelColor(i, strip.Color(255, 150, 120)); // pour définir la couleur    }  } else {    for (int i = 0; i < NUM_LEDS; i++) {      strip.setPixelColor(i, strip.Color(0, 0, 0));    }  }

 // Show the updated LED strip  strip.show();}

- Simulation du circuit électronique en réel via le logiciel Arduino
- Réalisation en réel du circuit électronique via le Arduino
Lors du test, nous nous sommes rendu compte que 6 LED n'était pas suffisant pour éclairer le tableau alors nous avons décidé de mettre 12 LED. Nous sommes passé par une soudure de deux rubans LED entre eux.

Code pour ruban de 12 LED :

#include <Adafruit_NeoPixel.h>
// Define the LED strip parameters#define NUM_LEDS 12 // nous avons 12 LED sur le ruban #define LED_PIN 13 // le ruban de LED est branché sur la PIN 13
Adafruit_NeoPixel strip(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);
// Define the HC-SR04 parameters#define TRIGGER_PIN 9#define ECHO_PIN 10
long duration;int distance;
void setup() {  // Start the serial communication  Serial.begin(9600);

 // Initialize the LED strip  strip.begin();  strip.show(); // Initialize all pixels to 'off'

 // Initialize the HC-SR04  pinMode(TRIGGER_PIN, OUTPUT);  pinMode(ECHO_PIN, INPUT);}
void loop() {  // Trigger a pulse to the HC-SR04  digitalWrite(TRIGGER_PIN, LOW);  delayMicroseconds(2);  digitalWrite(TRIGGER_PIN, HIGH);  delayMicroseconds(10);  digitalWrite(TRIGGER_PIN, LOW);

 // Measure the duration of the pulse  duration = pulseIn(ECHO_PIN, HIGH);

 // Calculate the distance  distance = duration * 0.034 / 2;

 // Print the distance to the serial monitor  Serial.print("Distance: ");  Serial.print(distance);  Serial.println(" cm");

 // Update the LED strip  if (distance <= 15) { // le ruban LED s'allume si on se place à une distance inférieur ou supérieur à 30 mètres devant le tableau

   for (int i = 0; i < NUM_LEDS; i++) {      strip.setPixelColor(i, strip.Color(255, 90, 0)); // pour définir la couleur    }  } else {    for (int i = 0; i < NUM_LEDS; i++) {      strip.setPixelColor(i, strip.Color(0, 0, 0));    }  }

 // Show the updated LED strip  strip.show();}

Image de réalisation de la soudure :

1. Allumer l'appareil de soudure à 300°C

2. Utiliser la clé pour effiloché l'extrémité du fils

3. Chauffer l'étain qui servira ensuite à chauffer les fils afin d'effectuer la soudure via fusion des matériaux

4. Utiliser l'étain pour faire un point chaud à deux endroit différents : à l'extrémité du ruban LED et à l'extrémité du fils à fixer sur le ruban LED
5. Faire un point chaud à un endroit spécifique : sur l'extrémité du ruban LED et du fils fixé sur le ruban LED pour les assembler ensemble

6. Résultat

7. Collage des LED sur le Tableau INARI

Ne pas oublier de mettre des gants, des lunettes de protection
Image du montage électronique :

c. partie découpe laser boîte 2D
1. Conception Trotec

2. Impression

d. assemblage
1. Assemblage boîte 2D

Avant assemblage, on test le programme informatique pour savoir s'il fonctionne toujours :

2. Assemblage tableau

9. photos de l'objet final
1. Tableau INARI

2. Tableau INARI en fonctionnement

10. réflexions de pistes d'amélioration ou d'évolution du projet
Du MVP au produit fini :
- avec un algorithme IA changeant l'image en fonction de l'heure
- avec un écran matte anti-reflet, adaptable en fonction de la luminosité ambiante
Perspectives :
- ajouter à l'algorithme l'option de changement d'image en fonction de la température ou de la musique
- ajouter des choix de cadre différents
Aussi, nous aurions voulu utiliser un capteur PIR à la place du capteur dé détection HC-SR04. Car le capteur de détection PIR permet un détection plus large sur les côtés alors qu'avec le capteur HC-SR04, il faut se mettre bien devant. Seulement, le FabLab n'avait pas de capteur PIR dans ces stocks.

11.  sources des tutoriels, inspirations, ressources utilisées (à insérer au fil de la documentation)
Les données et statistiques sur le marché de la décoration d'intérieur - modelesdebusinessplan.com
Le gaspillage, c’est aussi pour les objets du quotidien - ConsoGlobe
Business Model Canva - BPI France

El Distributo, le distributeur de formule anhydre


El Distributo est un packaging permettant de distribuer les formules anhydre dans le milieu de la cosmétique. Voici un lien permettant de comprendre notre offre de valeur et le contexte du marché :

https://www.canva.com/design/DAFfOwwd1y8/MnoBcbNvZZsxAk6cHHQp9Q/edit?utm_content=DAFfOwwd1y8&utm_campaign=designshare&utm_medium=link2&utm_source=sharebutton

1) Conception 3D
Dans un premier temps nous nous somme rendu sur Tinkercad pour la conception 3D de notre produit afin de pouvoir mettre en place une impression 3D de nos prototypes. Nous avons estimer qu'un packaging de 16 cm était acceptable pour l'utilisation que nous allons en faire.

Nous avons donc dans un premier temps modélisé un cylindre de 15 cm de haut et de 5 cm de diamètre. Puis nous allons le modéliser un autre cylindre qui nous permettra de percer le premier. Nous allons alors sélectionné les deux cylindre et cliquer sur union.

Pour contrôler la distribution des formules nous allons modélisé une visse sans fin qui permettra de distribuer la formule avec un mouvement de rotation.

Nous modélisons ensuite des rectangles qui vont permettre de rattacher la visse au cylindre. Nous les avons ensuite placé sur le cylindre et avons cliqué sur union.

Nous avons ensuite modélisé un fond pour notre cylindre légèrement plus épais que notre visse pour laisser passer la bonne dose de produit (ni trop ni pas assez). Le client (marque de cosmétique) pourra ajuster la taille de ce fond pour qu'il y ait un trou plus ou moins grand en fonction de la formule et des besoins des consommateurs (soin, maquillage ou coloration)

Nous avons ensuite modélisé un deuxième cylindre, identique au premier sans la visse. Ce deuxième cylindre accueillera la formule.

Nous avons ensuite modéliser un pot pour réceptionner la formule qui tomberait dedans.

Nous avons ensuite importé les fichiers en format STL sur Idea Maker. nous avons choisir une haute qualité, avec une densité de 15% car notre produit n'a pas besoin d'être hyper solide pour son usage. Nous n'avons pas besoin de support mais nous avons besoin d'une aide à l'adhérence.

cliquer sur slice

Nous avons donc commencer l'impression après avoir exporter le fichier sous format G code et mit sur une clef USB puis mit sur l'imprimante avec un filament Pro PLA blanc
- voir si l'impression a réussi après les 16h : Impression réussie !
2) Une PLV pour mettre en valeur notre produit
On a importé sur Inskape le logo El Distributoau format png

On a ensuite sélectionné la forme, puis on a fait  Chemin -> Vectoriser un objet matriciel

Objet-> Fond et contour-> Fond Uni rouge

Réglage épaisseur : 0,5 mm

Nous l'avons ensuite exporté sous format .svg
Sur Trotec on importe le logo au format svg
On sélectionne les couches nécessaires

On a fait créer la tache, on a placé le logo sur la plaque, on a ensuite sélectionné le matériel (peuplier 3mm, on règle la hauteur de la plaque et la position du laser avec les flèches de la machine)
Une fois que c'est fait, on fait "produire" (résultat final)

Projet final - Justine LANNI & Jacqueline YOGENDRAN

...
🧪 UE LABEL VERT



Label vert: La larve mangeuse de plastique

Nom : LE TOQUIN Juliette, SOUFIANI Noha, BOUATIR Fatima Ezzahraa, FERNANDES PEREIRA Alizée
Projet : La larve Galleria Mellonella mangeuse de plastique (PS/PEBD)

Cadre: UE Label Vert 2 (2022/2023)

Introduction:
Le plastique est une matière qui pollue énormément et elle se retrouve bien trop souvent dans l’environnement.  Le problème qui se pose est la dégradation totale ou partielle du plastique. On souhaite donc au travers de notre projet présenter une nouvelle méthode de dégradation du plastique qui est encore en cours de développement. En effet, des recherches récentes ont essayé de déterminer la capacité de certaines larves à dégrader le plastique.

Objectif : Notre projet a pour but d’étudier l’efficacité de l'une des larves étudiées, la larve Galleria Mellonella, à dégrader le plastique et de pouvoir comparer les différents résultats. Dans notre cas, nous prendrons deux types de plastiques différents: du polyéthylène basse densité (PEBD) et du polystyrène (PS). En effet, nous cherchons donc à mettre en confrontation nos différentes expériences.

Etude bibliographique et documentation
Création d'un poster
Expérience au Fablab (Biologie-Chimie et Prototypage)

Galleria mellonella (Gm) est une espèce de Lepidoptera dans la famille Pyralidae. Nommée teigne de ruche, c'est une larve que l'on utilise principalement pour la pêche. Son cycle de développement varie de 4 semaines à 6 mois selon les conditions et comprend 4 phases (œuf, larve, nymphe et adulte). C'est dans les alentours de mars qu'elle se développe et atteint son pic autour d’août. Dans le cadre de ce projet, nous allons nous intéresser seulement à son stade de larve.

Expérimentation/Manipulation:

I/ Protocole expérimental: Préparation des tests + témoin
Fablab prototypage :

1. Broyer les bouteilles en PEBD

Fablab de biologie/chimie:
2. Nettoyer les béchers/erlenmeyers/cristallisoirs à l'éthanol
3. Faire des copeaux de cire d'abeille à l'aide d'un économe/scalpel
4. Émietter le PS en petits morceaux
5. Avant toutes préparations, peser les récipients, le PEBD, le PS, les copeaux de cire, et les larves à l'aide d'une balance de pesée

6. Mises en places des tests/témoins* :

Témoin: Bécher de 500 ml + 10.85 g de cire + 43 larves Gm (18.855 g)

Test 1: Bécher de 250 ml (90,5968g) + 10.85 g de cire + 34 larves Gm (15.9 g) + 0.7 g de PS
Test 2: Bécher de 250 ml (118,57g) + 10.85 g de cire + 36 larves Gm (15.5419 g) + 10.8 g de PEBD (broyé)
Test 3: Erlenmeyer de 250 ml (134,4g) + 36 larves Gm (16.05g)  + 17.15 g de PEBD (broyé)
Test 4: Erlenmeyer de 250 ml (134,6g) + 44 larves Gm (20,27g)  + 1 g de PS
Test 5: Cristallisoir de 795 g + 29 larves Gm (14.6296 g) + 2,6301 g de PEBD (film alimentaire). Le cristallisoir est recouvert par son couvercle en verre.
Test 6: Cristallisoir de 991.84 g + 10.88 g de cire + 38 larve Gm (18.1318 g) + 2.7634 g de PEBD (film alimentaire). Le cristallisoir est recouvert par son couvercle en verre.
Test 7: Bécher de 800 ml (243.38 g) + 38 larves Gm (18.547 g) + 1.0735 g de PS

7.  Mettre les tests/témoin dans une grosse boîte en plastique que l'on mettra dans une salle close, sans lumière, à 22-23°C.
* récipients couverts avec du papier aluminium rempli de petits trous

Matériel nécessaire à la réalisation de nos expériences:

Fablab de Biologie: 350 larves Gm vivantes, bloc de cire d'abeille, 1 bécher de 500 ml, 2 béchers de 250 ml, 2 erlenmeyers de 250 ml, 2 cristallisoirs, papier aluminium alimentaire, une Brucelles en plastique, plaque de polystyrène, 2 bouteilles en PEBD, thermomètre mercure, scalpel, économe

Fablab de Chimie: Accessoire ATR diamant, éthanol de nettoyage
Fablab prototypage: broyeuse

II/ Observations : Début & fin d’expériences

Dates, T(°C),

Témoin

Test 1

Test 2
Test 3
Test 4
Test 5
Test 6
Test 7

27/03/2023, 14h40, 22°C

8 mortes
8 mortes
10 mortes

X
X
X
X
X

29/03/2023, 16h21, 23°C

6 mortes
1 morte
4 mortes
12 mortes
9 mortes
X
X
X

31/03/2023, 9h57,
23°C

4 mortes*
5 mortes
1 morte*

8 mortes* + perte de PE

13 mortes*
X
X
X

03/04/2023, 11h17,
22°C

2 mortes *

0 morte

5 mortes *

5 mortes
10 mortes
X
X
X

05/04/2023, 11h, 22.5°C

0 morte *

0 morte *

0 morte *

0 mortes
6 mortes
X
X
X

07/04/2023, 12h,
24°C

0 morte

2 mortes

0 morte

1 morte
0 morte
X
X
X

11/04/2023, 13h53,
23°C

1 morte

0 morte

0 morte *

1 morte
1 morte
2 mortes
X
X

13/04/2023, 10h30,
23°C

0 morte

0 morte

0 morte

0 morte
0 morte
1 morte
1 morte
1 morte  (+1 cocon)

14/04/2023,
14h,
22,5°C

0 morte

0 morte

1 morte

0 morte
1 morte
1 morte
0 morte
5 mortes

18/04/2023, 13h20,
23,5°C

1 morte

1 morte

1 morte

4 mortes
1 morte
1 morte
1 morte
8 mortes

23/03/2023, 12h, 23°C: mise en place du témoin et des tests 1 et 2 ( arrivée des larves depuis 2j (au frais))
27/03/2023, 14h50, 22°C: mise en place des tests 3 et 4 (arrivée jour même)
07/04/2023, 12h, 24°C: mise en place du test 5 (arrivée des larves la veille (au frais))
11/04/2023, 15h15, 23°C: mise en place des tests 6 et 7 (arrivée des larves le 6/04/23 (au frais))

03/05/2023 - 05/04/2023: diminution forte de la cire
* présence de soie

III/ Résultats fin d’expérience

Témoin
Test 1
Test 2
Test 3
Test 4
Test 5
Test 6
Test 7

Durée

3 semaines et 1 jour
3 semaines et 1 jour
3 semaines et 1 jour
2 semaines et 6 jours
2 semaines et 6 jours
1 semaine 
5 jours
5 jours

Début
43 larves Gm : 18.855 g
34 larves Gm: 15.9 g
36 larves Gm :  15.5419 g
36 larves Gm : 16.05 g
44 larves Gm : 20,27 g
29 larves Gm : 14.6296 g
38 larve Gm : 18.1318 g
38 larves Gm : 18.547 g

Fin

20 larves vivantes : 6.4352g
et un cocon

17 larves vivantes: 6.1753g

14 larves vivantes: 4.7291g 
et un cocon

5 larves vivantes: 1,712g

2 vivantes: 0.7676g
et un cocon

23 vivantes: 10.462g
et un cocon

35 vivantes: 14.966g
et un cocon

23 larves vivantes: 9.647g
et un cocon

Total de larve(s) morte(s)

23 mortes (12.4498g)

17 mortes (9.7247g)

22 mortes (10.8128g)

31 mortes (14.338g)

42 mortes (19.5024g)

6 mortes (4.1676g)

3 mortes (3.1658g)

15 mortes (8.9g)

Photos expériences

Témoin + Test 1 + Test 2

Test 3

Test 4

Test 5

Test 6

Test 7

Témoin + Test 1 à 7

IV/ Analyses expérimentales

Analyse Statistique & Biologique

Témoin
Test 1
Test 2
Test 3
Test 4
Test 5
Test 6
Test 7

% en masse de larve Gm morte
66.03 %
61.16 %
69.57 %
89.33 %
96.21%
28.49 %

17.46 %
47.99 %

Forte diminution de cire dans les test 1 & test 2 à contrario de la quantité des plastiques (PS, PEBD broyé, PEBD film)
18/04/2023: Larves très actives dans les test 5 & test 7

Analyse IR en ATR

Nom du plastique

PEBD
PS

Pics Caractéristiques

Alcane

Elongation C-H:  2850-3000 cm-1 (forte intensité)
Déformation C-H: 1350-1480 cm-1 (moyenne intensité)

Alcane (voir à gauche)
Aromatique

Elongation C-H: 3000-3100 cm-1 (moyenne intensité)
Déformation C-H: 680-900 cm-1 (forte intensité)
Elongation C=C:  1500-1650 cm-1 (forte intensité)

Spectres IR (31/03/2023)

Spectres IR (18/04/2023)

EXPLOITATION DES RESULTATS

Statistique & Biologique

Cire + plastique (PS/PEBD) : % de larves mortes proches --> car larves on plus mangé la cire que le plastique

Plus de larves mortes en présence de PS seul

IR en ATR

Comparaison du spectre IR du PEBD avec les deux spectres des "Larves test 2" et celui des "Larves test 3": Nous pouvons observer que les pics caractéristiques du PEBD ne sont pas présents sur les spectres des larves, dont les tests sont composés de PEBD. Pour illustrer ce propos, nous pouvons relever que les 2 pics de forte intensité à 2800 cm-1 et 2900 cm-1 présent sur le spectre IR du PEBD, ne sont pas observable sur sur les spectre du test 2 et 3.

Comparaison du spectre IR du PS avec les deux spectres des "Larves test 1" et celui des "Larves test 4": Même observation que celle pour le PEBD: nous n'observons pas de pics caractéristiques du PS sur les spectres des larves.
Comparaison du spectre IR des "Larves du témoin" avec tous les autres spectres des larves: Les spectres des larves sont tous similaires malgré leurs conditions différentes.

Comparaison du spectre des plastiques de départ (PEBD, PS, film plastique) avec les plastiques de fin d’expérience: Ce sont les mêmes.

CONCLUSION

Notre expérience a permis l’étude et l’observation du développement des larves Galleria Mellonella. Celles exposées uniquement aux plastiques s’en sont nourries et semblent anormalement plus grandes et grosses que celles se nourrissant aussi de cires. La spectroscopie IR en ATR ne présente pas de résultats concluants, car elle ne permet pas de obtenir une analyse de caractérisation assez précise.  La présence de résidus de PS et PEBD nous est donc indiscernable.
Les résultats observés peuvent avoir été causé par de nombreux paramètres que nous avons du changer comparer à ceux établit dans les articles de références. Ainsi nous avons utilisé des plastiques (PEBD et PS) non stérilisés, effectuer des analyses IR en ATR, effectuer nos tests dans des béchers/erlenmeyers/cristallisoirs. Or eux, dans leurs cas, le plastiques avaient été stérilisés avant son introduction dans les tests à partir d’éthanol, ils ont caractérisé leurs éléments à travers des analyses plus précisent de l'ATR: FTIR, GC-MS ou l'imagerie hyperspectral.

BIBLIOGRAPHIE

Lou, Yu, et al. « Biodegradation of Polyethylene and Polystyrene by Greater Wax Moth Larvae ( Galleria Mellonella L.) and the Effect of Co-Diet Supplementation on the Core Gut Microbiome ». Environmental Science & Technology, vol. 54, no 5, mars 2020, p. 2821‑31. DOI.org (Crossref), https://doi.org/10.1021/acs.est.9b07044

Yang, Jun, et al. « Evidence of Polyethylene Biodegradation by Bacterial Strains from the Guts of Plastic-Eating Waxworms ». Environmental Science & Technology, vol. 48, no 23, décembre 2014, p. 13776‑84. DOI.org (Crossref), https://doi.org/10.1021/es504038a
Cassone, Bryan J., et al. « Role of the Intestinal Microbiome in Low-Density Polyethylene Degradation by Caterpillar Larvae of the Greater Wax Moth, Galleria Mellonella ». Proceedings of the Royal Society B: Biological Sciences, vol. 287, no 1922, mars 2020, p. 20200112. DOI.org (Crossref), https://doi.org/10.1098/rspb.2020.0112
Bombelli, Paolo, et al. « Polyethylene Bio-Degradation by Caterpillars of the Wax Moth Galleria Mellonella ». Current Biology, vol. 27, no 8, avril 2017, p. R292‑93. ScienceDirect, https://doi.org/10.1016/j.cub.2017.02.060.

Synthèse de nanoparticules d'argent à partir de peaux de fruits (gr 5)


Informations

Mouna Karihila, Julia Krystyanczuk, Isabelle Zheng, Meline Zheng
mouna.Karihila@etu.sorbonne-universite.fr , julia.Krystyanczuk@etu.sorbonne-universite.fr, isabelle.Zheng@etu.sorbonne-universite.fr, meline.zheng.1@etu.sorbonne-universite.fr
L3 Chimie et Double-Majeure Chimie-Biologie
30 septembre 2022 - 22 avril 2023

Contexte
Les nanoparticules d'argent (AgNPs) sont déjà utilisés dans certains de nos produits cosmétiques comme les sprays désinfectants, et sont particulièrement intéressantes pour leurs propriétés antibactériennes et antifongiques¹. En revanche, les phytonanoparticules d’argent issues d’une synthèse verte à partir de déchets alimentaires procurent à ces particules des effets supplémentaires tels qu’un fort pouvoir réducteur pour lutter contre le stress oxydant dû à un excès d'espèces réactives à l'oxygène². En effet, cela peut causer des maladies comme le cancer mais est aussi à l'origine du vieillissement cutané car les radicaux libres dégradent le collagène et font apparaître ce qu'on appelle des rides³. Les AgNPs ont la particularité de percer la membrane bactérienne et de s'infiltrer pour se fixer sur les composants cellulaires internes essentiels leur empêchant ainsi la prolifération de la colonie bactérienne. Une bactérie anéantie par l'argent est capable de condamner des bactéries vivantes atteignant à une mortalité jusuq'à 99,99% qu'on appelle "l'apocalypse zombie" induit par l'effet de l'argent⁴.
Objectifs
On souhaite alors, dans notre expérience, synthétiser des nanoparticules d'argents à partir de peaux de fruits. Pour cela, on s'est basée sur un protocole retrouvé sur des articles scientifiques. On va prendre des peaux de fruits de banane et d'agrumes, ici l'orange et la clémentine. On va caractériser nos produits de synthèse par spectroscopie UV-visible et par infrarouge.

Protocole

Prélever environ 0,2 g de zeste d'orange et laver avec de l'eau désionisée.
Broyer à l'aide d'un mélangeur domestique, puis remuer pendant environ 20 min dans 50 ml d'eau à 50 °C.

Laisser refroidir à température ambiante.
Filtrer et garder l’extrait aqueux.

Préparer 7,5 mL de solution d'amidon soluble à 5 % (pourcentage/volume) avec 6 mL d'extrait aqueux
Ajouter 20 mL de AgNO3 à 0,01 M.
Ajuster le pH jusqu’à atteindre un pH autour de 14 à l’aide d’une solution aqueuse de 2 M KOH.

La solution devient progressivement noire, ce qui indique la formation de nanoparticules d'argent.

Centrifuger avec de l’eau désionisée puis 1 fois avec l’acétone ou éthanol à 6 000 tr/min pendant 15 min.

// Précaution à prendre ! //
AgNO3 0,01 M : corrosif, lésions occulairesKOH : corrosif

Matériel

Amidon soluble de PROLABO

Peaux d'orange, de clémentine et de banane

Balance et Coupelle pour peser

Mélangeur domestique (Blender)

Bain Marie + spatule pour mélanger (→ Eau à 50°C)

Eprouvette graduée de 50 mL

Bécher de 100/250 mL

Pipette jaugée de 20 mL

Filtre à café

Entonnoir (pour solide et liquide)

Pipettes Pasteur

pH mètre (papier pH)

Centrifugeuse

Bidon de récupération pour métaux lourd

Cuve en qwartz pour la caractérisation

Mortier et pilon
Pissette d'eau distilée

Machines utilisées
Spectroscopie UV visibleSpectroscopie FTIR-ATR

Journal de bord

Vendredi 24 février 2023
≈ 2h au FablabTout d'abord, nous avons séché nos peaux d'orange/clémentine et banane grâce au dessiccateur. On les a laissé plusieurs jours au dessiccateur.
On a préparé la solution d'amidon 5% qui nous est nécessaire, avec 5g d'amidon soluble et 100 mL d'eau.
De plus, on a préparé notre solution aqueuse de KOH avec 11,2g de KOH solide (56,11g/mol) pour 100 mL d'eau.

Lundi 6 mars 2023
≈ 5h au Fablab Des substances macromoléculaires se sont formées dans notre solution d'amidon, on doit donc refaire celle-ci à chaque fois qu'on va l'utiliser. Pour cela, on va préparer 7,5 mL de solution d'amidon en utilisant 0,375 g d'amidon soluble solide avec 7,5 g d'eau.

On a réussi à broyer nos peaux d'orange, de clémentine et de banane avec un mixeur. On a obtenu un solide hétérogène (avec gros grains et petits grains) pour la clémentine et l'orange, quant à la banane, on a continué au mortier et pilon pour avoir des grains encore plus fins.
On a tout d'abord commencer avec les peaux d'orange. Pour cela, on en a prélevé 0,2g et on les a remué pendant 20 mins dans un bain d'eau à 50°C avec 50 mL d'eau distillée pour ensuite les laisser refroidir à T°amb. L'extrait aqueux est filtré à l'aide d'un filtre à café. Nous avons mesuré les valeurs d'absorbance pour cet extrait.
Dans un nouveau bécher, 6 mL de solution aqueuse ont été prélevée puis 7,5 mL de solution d'amidon 5% y ont été ajoutés. Une nouvelle mesure d'absorbance a été faite. On rajoute 20mL de AgNo3 dans le mélange puis on procède une autre mesure d'absorbance. Ces mesures représentent les zéros de nos expériences.

Le pH de notre solution de départ est de 5-6.
Par la suite, on a décidé après de mesurer la valeur d'absorbance après chaque ajout de KOH (0,5 à 1 mL à chaque fois) jusqu'à atteindre pH = 14. La mesure s'est faite à l'aide de papier pH qui malheureusement ne fut pas très précis.
Suivi de KOH ajouté:- 1 mL de KOH → pH ≈ 10- 1,5 mL de KOH → pH ≈ 11- 2 mL de KOH → pH ≈ 11-12- 3 mL de KOH → pH ≈ 12- 4 mL de KOH → pH ≈ 13- 5 mL de KOH → pH ≈ 14
Une solution noire / marron est obtenue après le premier ajout de KOH - on a bien la synthèse des AgNPs !
Après un premier passage à la centrifugeuse à 6000 rtm pendant 15 mins à 25 °C, le surnageant obtenue est de couleur jaune, le culot est de couleur noire - ce sont nos AgNPs. On avait 3 tubes de centrifugation de 15 mL où 9,3 mL de solution se trouvaient dans chaque tube. Pour bien équilibrer dans la centrifugeuse, on a ajouté un quatrième tube de centrifugation avec 9,3 mL d'eau.
On a alors éliminé le surnageant (que l'on a tout de même gardé de côté). On doit ensuite laver avec de l'eau dans chacun de nos tubes contenant les culots. C'est ainsi que l'on ajoute 9,5 mL d'eau distillée dans chaque tube.

Pour la prochaine fois, il faut faire une nouvelle centrifugation avec les mêmes paramètres que précédemment sans oublier de bien agiter les tubes avant de démarrer (ne rien ajouter dans les tubes, ils sont prêts pour la centrifugeuse). Et enfin, ce lavage à l'eau, réaliser un lavage à l'acétone en procédant de la même façon.

Vendredi 10 mars 2023
≈ 2h au FablabOn a commencé par lancer la centrifugation à 6000 rtm pendant 15 mins à 25 °C, ce qui a permis de faire le lavage à l'eau de nos particules. Puis, on a enlevé le surnageant et réaliser le lavage à l'acétone. On laisse sécher à T°amb.
On a réalisé les spectres InfraRouge des différents peaux de fruits que nous avons grâce à la spectrométrie FTIR-ATR. (Fichier Administrateur 02 (IR) → peau de banane )
En parallèle, on a débuté ce même protocole pour la peau de clémentine et de banane. Ainsi, on a prélever 0,2 g de chaque que l'on a remué pendant 20 mins dans un bain d'eau à 50°C avec 50 mL d'eau distillée pour les laisser refroidir à T°amb. Pour la clémentine, l'extrait aqueux est filtré à l'aide d'un filtre à café. Pour la banane, nous avons gardé notre extrait aqueux avec les grains de peaux de banane. Nous avons mesuré les valeurs d'absorbance pour ces deux extraits.

Aujourd'hui, nous avons débuté par la clémentine. 7,5 mL de solution d'amidon 5% sont ajoutés à notre extrait de aqueux. On a ajouté les 20 mL de AgNO3 et on a procédé aux mesures d'absorbance. ET C'EST À PARTIR DE LÀ QU'ON REMARQUE QUE L'ON A OUBLIÉ DE PRÉLEVER LES 6 ML D'EXTRAIT AQUEUX... On doit alors tout refaire mais la prochaine fois...
Note pour plus tard : ne pas oublier de prélever seulement 6 mL d'extrait aqueux pour la caractérisation. Ne pas prendre tout l'extrait !
On a alors débuté la mesure de l'absorbance de la banane avec 6 mL d'extrait, où l'on a ajouté les 20 mL de AgNO3. On a réalisé une mesure d'absorbance. Par manque de temps, on a laissé notre solution dans un récipient sombre que l’on a mis au placard.
Pour la prochaine fois, refaire la solution aqueuse de peau de clémentine. Prévoir le chauffage (de 20 mins à 50°C), les 7,5 mL de solution d'amidon et les 20 mL de AgNO3. Si on est à plusieurs, en parallèle du chauffage de 20 mins, faire les mesures d'absorbance ET de pH pour les peaux de banane.Pour faire la caractérisation de la clémentine, ne pas oublier de ne prélever QUE 6 mL d'extrait aqueux.

Vendredi 24 mars 2023
≈2h
On a commencé par prélever 0.2g de clémentine que l’on a versé dans un bécher contenant 50mL d’eau distillée. Après 20 mins de chauffage à 50°C, on a laissé refroidir et filtré avec un filtre à café.
On a préparé une solution d’amidon, avec 0.382g d’amidon soluble et 7.5mL d’eau distillée.
On a souhaité faire l’ATR de nos nanoparticules d’argent à partir de l'extrait de peau d'orange qu'on avait laissé sécher depuis la séance précédente. Cependant, dans nos tubes, on avait vraiment eu peu de produits, lors de notre analyse en IR, il n'y avait pas assez de nanoparticules pour recouvrir le diamant du spectromètre IR. Ainsi, on peut tout de même conclure que la synthèse a marché grâce à notre caractérisation par UV. Mais nous n'avons aucune certitude sur la 'véracité' de notre produit qu'on a formé, pour cela une caractérisation sous rayon X serait pertinente pour pouvoir comparer nos résultats avec ceux présentés sur l'article. En effet, on ne peut déterminer si ce produit correspond bel et bien à nos nanoparticules d'argent qu'on souhaitait synthétiser qu'avec une caractérisation UV, puisque la couleur observée peut être également due à la présence de d'autres éléments.
De plus, on a souhaité faire les mesures d’absorbance pour les peaux de banane. Cependant, notre solution est devenue noire, sûrement dû à une réaction d’oxydation depuis la dernière séance (temps de réaction trop long - presque 2 semaines). Ainsi, on n’a pas pu réaliser nos mesures car on s'attendait à obtenir une solution jaune après ajout de AgNO3, comme présenté dans l'article.
Pour finir, on a alors prélevé 6mL d’extrait de clémentine, où on ajoute la solution d’amidon, les 20 mL d’AgNO3 pour réaliser nos mesures d’absorbance ( clémentine seule, clémentine-amidon, clémentine-amidon-AgNO3,...)
Ecrire le suivi du KOH :

- 1 mL de KOH → pH ≈ 9- 2 mL de KOH → pH ≈ 10- 3 mL de KOH → pH ≈ 10- 4 mL de KOH → pH ≈ 12
Pour la prochaine fois, faire les centrifugations, les différents lavages pour la clémentine. Peut-être recommencer l'expérience de la banane en fonction du temps restant.

Lundi 27 mars 2023
Pour la solution de clémentine, on a préparé 3 tubes de centrifugation de 15mL -> 18,48g dans chaque tube.Equilibration avec de l'eau dans un quatrième tube. On peut alors procéder aux différentes étapes de lavage.
Notre surnageant est noir. On a ensuite réalisé un lavage à l'eau avec un nouveau programme : 10 000 rtm pendant 15min à 20°C. Le surnageant est de couleur roux. On lave à présent à l'acétone. On a souhaité relaver à l'acétone pour avoir un meilleur lavage.
En parallèle, on a retenté notre caractérisation UV avec la peau de banane en utilisant 6mL d'extrait de peau de banane, 20 mL d'AgNO3, et du KOH.
Le pH initial était de 5. Suivi du KOH : - 1 mL de KOH → pH ≈ 14On a alors arrêté l'expérience, notre pH était déjà trop basique. On a supposé que le KOH était trop concentré. La couleur initialement jaune de notre extrait de banane avec l'AgNO3 est devenue noire après ajout de KOH.

On passe ainsi notre solution à la centrifugeuse pour 10 000 rtm pendant 15 mins à 20°C . Puis on réalise un lavage à l'eau de nos tubes pour la banane.
On a changé nos paramètres car nos nanoparticules sont trop légères, nécessitant ainsi plus de puissance pour centrifuger. De plus, on a perdu beaucoup de produit car nos surnageants étaient foncés.
On a finalement préparer des boites de pétri pour l'extrait de clémentine. Permettant le séchage de nos particules sous la hotte.
A faire prochainement, la centrifugation avec l'acétone pour la banane puis boite de pétri pour banane. Les tubes sont laissés dépourvu d'acétone sur notre paillasse. Faudra ajouter acétone.

Lundi 3 avril
On a commencé par ajouter de l'acétone dans nos tubes de centrifugation. (masse de nos tubes ≈ 18.17g). On laisse centrifuger à 10 000 rtm pendant 15 mins à 20°C.

Pendant la centrifugation, on réalise l'infrarouge ATR de notre produit de clémentine.

Vendredi 7 avril
Dans la suite, nous avons appliqué le même protocole mais avec de l'eau au lieu de l'extrait aqueux.
Prélèvement des mesures UV, au bout de 2 mL de KOH (2M), la solution a atteint un pH de 14.

On a introduit le mélange dans 3 tubes pour centrifuger à 15000 rpm pendant 15min à température ambiante. Ensuite on a utilisé le même programme pour procéder aux lavages à l'eau et l'acétone. Ne pas oublier de secouer à chaque lavage et s'assurer que les tubes font chacun le même poids.

 

Laisser sécher à T°ambiante dans une boite de pétri sous hotte et caractérisation ensuite par FTIR ATR.

Résultats
D'après notre bibliographie, on devrait observer en UV une augmentation progressive de l'absorbance à 404 nm ¹, ce qui indiquerait la formation des nanoparticules d'argent. Nous n'avons pas réussi à observer cela, ce qui peut être dû à la présence d'impuretés, la solution de KOH trop concentrée ou encore le prélèvement d'un volume assez faible de nitrate d'argent peu concentré. Un résultat plutôt favorable, avec une augmentation progressive de l'absorbance, est observé dans le cas de la peau de clémentine. Les spectres IR sont différents de la littérature, et nous n'observons aucun pic qui serait caractéristique à une vibration de liaison impliquée dans les AgNPs.
Pour compléter cette étude, il serait intéressant de réaliser :

Une application sur des bactéries pour illustrer les propriétés antibactériennes et observer s'il y a potentiellement une résistance qui s'est développée contre ces particules⁵ ;
Une caractérisation par diffraction Rayon X, microscopie à balayage électronique ou à transmission électronique ;
Une solution d'AgNO₃ plus concentrée - pour obtenir un meilleur rendement (moins de solvant).

Conclusion
Il est difficile de caractériser les particules d'Argent avec des outils simples et accessibles. Les caractérisations effectuées ne nous permettent pas de confirmer si nous avions bien synthétisé des AgNPs. La synthèse est complexe avec un rendement faible. L'utilisation de métaux lourds nécessite une filtration laborieuse pour récupérer les métaux.
Les risques sanitaires et environnementaux associés à ces nanoparticules sont également énormes : des travaux montrent que ces nanoparticules sont particulièrement néfastes pour les animaux aquatiques et terrestres, de plus les études sur la dangerosité de ce matériau pour la peau sont encore insuffisantes⁵. Le prix est aussi non négligeable, la solution de AgNO₃ est très coûteuse.
La part des contraintes est plus importante que les bénéfices, elles doivent être prises en compte lors de notre synthèse. La valorisation des déchets est certes intéressante mais l'utilisation de l'argent contrebalance cette idée de synthèse de AgNPs à partir de peaux de fruits.

Sources
(1) Konwarh, R.; Gogoi, B.; Philip, R.; Laskar, M. A.; Karak, N. Biomimetic Preparation of Polymer-Supported Free Radical Scavenging, Cytocompatible and Antimicrobial “Green” Silver Nanoparticles Using Aqueous Extract of Citrus Sinensis Peel. Colloids Surf. B Biointerfaces 2011, 84 (2), 338–345. https://doi.org/10.1016/j.colsurfb.2011.01.024.
(2) Paiva-Santos, A. C.; Herdade, A. M.; Guerra, C.; Peixoto, D.; Pereira-Silva, M.; Zeinali, M.; Mascarenhas-Melo, F.; Paranhos, A.; Veiga, F. Plant-Mediated Green Synthesis of Metal-Based Nanoparticles for Dermopharmaceutical and Cosmetic Applications. Int. J. Pharm. 2021, 597, 120311. https://doi.org/10.1016/j.ijpharm.2021.120311.
(3) Ecocentric. Radicaux libres, vieillissement de la peau & cosmétique. Ecocentric. http://www.ecocentric.fr/blog/index/billet/13505_radicaux-libres-antioxydants-cosmetique (accessed 2023-04-10).
(4) Silver turns bacteria into deadly zombies. https://www.science.org/content/article/silver-turns-bacteria-deadly-zombies (accessed 2023-04-10). (5) Exposition aux nanoparticules d’argent : mise à jour des connaissances. Anses - Agence nationale de sécurité sanitaire de l’alimentation, de l’environnement et du travail. https://www.anses.fr/fr/content/exposition-aux-nanoparticules-d%E2%80%99argent-mise-%C3%A0-jour-des-connaissances (accessed 2023-04-07).
(5) Exposition aux nanoparticules d’argent : mise à jour des connaissances. Anses - Agence nationale de sécurité sanitaire de l’alimentation, de l’environnement et du travail. https://www.anses.fr/fr/content/exposition-aux-nanoparticules-d%E2%80%99argent-mise-%C3%A0-jour-des-connaissances (accessed 2023-04-07).
https://doi.org/10.1016/j.colsurfb.2011.01.024
https://doi.org/10.1016/j.colsurfa.2010.07.024

🍏 UE MU5BIQ01 - Nutrition, Qualité et Santé



Mesure du curdling sur du lait de pois-chiche - Yofi

Projet réalisé en Co-Working avec Yofi par : Guillaume Camara, Noémie Dubar, Aydan Gun, Etienne Porquier
Un phénomène de "curdling" dans la boisson végétale

Tarte enrichie en protéines - Appétoque 1

Projet réalisé en Co-Working avec Appétoque par : Laura Segalas,  Mohammed Bedrane, Meryem Hadjili, Wissal Mansouri
Nouvelle formulation de tarte enrichie en protéines pour les séniors
Informations

Laura Segalas /  Mohammed Bedrane / Meryem Hadjili / Wissal Mansouri
Laura.segalas@etu.sorbonne-universite.fr / Mohammed.bedrane@etu.sorbonne-universite.fr / Meryem.hadjili@etu.sorbonne-universite.fr / wissalmansr@gmail.com

Master 2 : Nutrition Qualité et Santé
02/12 - 16/12

Contexte
La société Appétoque a fait le constat qu’il existe une grande insatisfaction concernant l’alimentation des seniors. Ils apprécient peu les produits enrichis qui leurs sont proposés et ne les terminent pas, ce qui a deux conséquences majeures : l’apport nutritionnel prévu par le personnel médical n’est pas atteint et cela génère énormément de gaspillage alimentaire.
Objectifs
Création d’une tarte enrichie en protéine pour les personnes âgées qui souffrent de problème de dénutrition et de mastication. La tarte doit être à texture adaptée et doit contenir un goût intense en fruit.
 IMG_6341.HEIC

Matériel

Une balance

Un mixeur
Des bols
Des cuillères et des couteaux
Un four

Une casserole

Des moules

Papier cuisson

Des poches à douilles

Un ciseau

Un crayon à papier

Une Marise

Flan enrichi en protéines - Appétoque 2

Projet réalisé en Co-Working avec Appétoque par : Léa Fernandes, Antoine Jin, Lucie Casanelli, Imane Mahmoudi
Développement d’un flan enrichi à destination des personnes âgées
CARNET DE BORD - APPETOQUE 2 

 PHASE 1 : CONCEPTION ET MISE EN ROUTE DU PROJET 

14/09 : Recherches pour se familiariser avec le sujet

Envoi d’un document de la start-up présentant le projet à notre demande afin que nous puissions commencer à nous préparer pour la première réunion

Recherches sur :

La start-up, leur produit et l’équipe

Les besoins nutritionnels de la population de séniors

Une rapide étude de marché et des pistes pour l’enrichissement et l’adaptation des textures

Des idées pour le flan (goûts, texture etc)

20/09 : Première réunion avec Appétoque

Présentation du projet et de la start-up

Présentation du cahier des charges

Supplémentation en protéines (minimum 10g/100g)

Supplémentation en un autre nutriment

Pas d’ingrédients synthétiques

Sans pate + texture homogène

Adapté aux troubles de la déglutition et de la mastication

Résistant à la congélation

Emballage recyclable => contrainte à traiter si le temps le permet

Action à mettre en place : créer une roadmap, lors des expérimentations créer un document permettant le suivi

 PHASE 2 : RECHERCHES BIBLIOGRAPHIQUES 

20/09 : Début des recherches bibliographiques

Supplémentation en protéines chez les sujets âgées

Isolat de lactosérum

Farine de lupin

Supplémentation en un autre nutriment et/ou fibres - potentiellement :

Algues / camu-camu (vitamine C)

Son de blé (fibres)

Lait (apport conséquent en calcium)

Ajout d’une source de matière grasse (oméga3)

Réglementation sur les allégations “riche en” et “source de”

Protocole expérimentations sur les textures

Prendre en compte les difficultés de mastication des séniors

Homogénéité du produit

Texture mixée à vérifier selon le protocole de la cuillère (IDDSI 4)

Surgélation/congélation + réglementations sanitaires

Réglementations température

Réglementation hygiène

06/10 : Deuxième réunion avec Appétoque 

Vérification des premières pistes de recherche

Questions sur l’isolat de lactosérum, sur la surgélation, sur l’allégation en fibres et ses conséquences sur la texture

Discussion sur les possibles supplémentations en un autre nutriment

Nécessité de mettre en place les premières recettes rapidement

06/10 : Début des recherches sur les recettes

Elaboration de nombreuses recettes qui pourrait convenir pour le projet

Calculs des macro- et micronutriments pour chacune des recettes avec un tableau Excel afin de connaître leurs valeurs nutritionnelles

16/10 : Mise en commun des différentes recettes

Recette classique enrichie avec isolat de lactosérum

Recette avec farine de lupin enrichie avec isolat de lactosérum

Test de la recette classique de flan sans isolat

Résultat : bonne texture mais un nouveau problème est relevé : la peau du flan qui se forme (probablement suite à la coagulation entre le lait et l’oeuf avec la chaleur) et qui est donc une nouvelle contrainte à traiter

17/10 : Troisième réunion 

Questions sur les allégations (réglementations à utiliser), sur le problème de la peau en surface (pistes : cuire au bain marie, à basse température, en couvrant le flan ou chercher une autre recette)

Présentation de nos idées et de nos recettes → validés

Favorise l’idée de la supplémentation en calcium ou vitamine C, importance de ne pas réduire trop l’apport calorique de notre flan (éviter les édulcorants à la place du sucre par exemple) car les personnes âgées surtout en cas de dénutrition ont besoin de cet apport en calorie

20/10 : Envoi de la liste d’ingrédients à Appétoque pour vérification

24/10 : Confirmation de la liste d’ingrédients par Appétoque

25/10 : Envoi de la liste d’ingrédients au Fablab

02/11 : Toujours en attente d’un date potentielle de livraison afin de pouvoir commencer les expérimentations (toutes les recettes que nous souhaitons expérimenter sont déjà prêtes)

22/11 : Quatrième réunion

Discussion autour d’ingrédients pour la supplémentation en protéines et en calcium

Discussion autour des expérimentations et de la rédaction du rapport

 PHASE 3 & 4 : EXPÉRIMENTATIONS ET RÉDACTION DU RAPPORT

28/11 : Réception de l’isolat de lactosérum, passage de la commande du reste des denrées + réunion avec Appétoque avec présentation du labo et point sur l’avancement

29/11 : Première expérimentation de la recette du flan classique - Test 1 

Variables modifiées : 

diminution de la maïzena à 50g au lieu de 100g

cuisson avec un aluminium pour limiter la formation de peau

Conclusion : texture tranchée et très aqueuse
Attention : une seule variable devra être modifiée pour les tests suivants car on ne sait pas lequel a eu un impact précisément.

01/12 : Test n°2

Variable modifiée : recette classique - diminution de la température de cuisson (160°C)

Conclusion : problème d’homogénéité mais texture moins aqueuse. Visuel plus attrayant, peau sur le dessus presque absente

02/12 : Cinquième réunion

Discussion autour des problèmes rencontrés lors des premières expérimentations et discussion des solution : ajout des protéines à la fin de la recette, ajout de quantité de protéines progressivement, mesure de la température de cuisson, etc

03/12 : Test n°3

Variable modifiée : recette classique - isolat ajouté juste avant l’enfournement et non dans le lait qui chauffe

Conclusion : bien meilleure texture, proche du flan mais trop compact toujours, goût des protéines trop présent

05/12 : Test n°4

Variable modifiée : recette classique - quantité d’isolat de lactosérum

Conclusion : pâte très liquide avant cuisson pour toutes les quantités, plus la quantité augmente plus le goût de l’isolat resort mais pas de grosse différence dans la texture

06/12 : Test n°5 et 6

Test n°5 : 
Variable modifiée : recette classique - temps de cuisson lors de la 2e chauffe moins important pour pas que la préparation prenne trop

Conclusion : mélange plus homogène mais toujours très liquide

Test n°6 : 
Variable modifiée : recette classique - cette fois le lait utilisé pour diluer les protéines sera directement du lait des 1L nécessaires au flan et pas du lait ajouté en plus du lait de base

Conclusion : flan râté avec trop d’alvéoles mais sûrement lié à la préparation

09/12 : Test n°7

Variable modifiée : recette classique - test d’une nouvelle méthode de cuisson : le bain-marie

Conclusion : meilleure texture obtenue jusqu’à présent mais la texture est encore beaucoup trop dense pour un flan

12/12 : Test n°8

Variable modifiée : ¾ de la maïzena utilisé

Conclusion : recette classique - texture redevient tranché comme avant, la maïzena est indispensable dans notre recette

13/12 : Test n°9

Variable modifiée : recette classique - réduction de la température de cuisson (150°C)

Conclusion : texture homogène mais toujours trop compact

14/12 : Sixième réunion

Discussion autour des problèmes de textures : idée d’utiliser seulement des jaunes d’oeufs ou de la crème

Discussion autour des résultats obtenus

Idée de faire une recette de flan/crème aux oeufs

16/12 : Test n°10

Variable modifiée : recette classique - utilisation uniquement des jaunes d’oeufs et plus des blancs d’oeufs

Conclusion : texture homogène mais toujours compact, couleur jaune qui se rapport du flan et goût de l’isolat de lactosérum masquée

20/12 : Test n°11

Variable modifiée : recette classique - remplacement de ¼ du lait par de la crème liquide

Conclusion : toujours une texture compact, mais le goût de la protéine est encore une fois bien masqué

27/12 : Test n°12

Variable modifiée : crème aux oeufs - expérimentation d’une nouvelle recette de crème renversée

Conclusion : texture lisse et beaucoup moins compact, très proche de la texture d’un flan classique.

28/12 : Test n°13 

Variable modifiée : crème aux oeufs - variation de la quantité de MG avec utilisation d’un lait entier

Conclusion : lait entier apporte une sensation plus farineuse au flan

28/12 : Test n°14

Variable modifiée : crème aux oeufs - diminution de la température de cuisson (160°C)

Conclusion : texture plus onctueuse et plus du tout de sensation farineuse

28/12 : Test n°15

Variable modifiée : expérimentation de la recette avec farine de lupin

Conclusion : flan beaucoup trop compact, colle aux dents et pas du tout adapté à notre projet, goût des pois chiches trop présent

03/01 : Test n°16

Variable modifiée : crème aux oeufs - expérimentation dans un grand moule

Conclusion : 50mL d’eau semble trop car de l’eau est ressortie du flan et cette sensation d’eau sur le flan est présente en bouche. De plus, le flan ne tient pas au démoulage

03/01 : Septième réunion

Discussion à propos de l’avancée du projet

Confirmation de la recette de flan/crème aux oeufs

Mis en place d’un questionnaire sur différents critères regroupés en 3 catégories :

Visuel

Texture

Goût

04/01 : Avancé du rapport : Introduction, chapitre 1 et 2 globalement rédigés et envoyés à Appétoque pour avoir un premier retour

05/01 : Test n°17

Variable modifiée : crème aux oeufs - réduction de l’eau à 30mL

Conclusion : démoulage correct, plus beaucoup d’eau mais un peu sur le papier cuisson

07/01 : Test n°18

Variable modifiée : crème aux oeufs - modification de la température à 180°C

Conclusion : expérimentation qui a nécessité plus de temps de cuisson mais ne relâche pas d’eau et texture de flan correct

09/01 : Test n°19, 20, 21, 22

Test n°19 : 
Variable modifiée : crème aux oeufs - remplacement d’⅓ de l’eau servant à diluer l’isolat par du jus de carotte afin de donner une couleur plus jaune/orangée

Conclusion : résultat avec une couleur proche du rose saumon plûtot que du jaune

Test n°20 : 
Variable modifiée : crème aux oeufs - pour essayer de rendre le flan plus compact, ajout de 5g de farine à la recette de flan aux oeufs (petite portion)

Conclusion : début de texture tranchée qui ne résout pas le problème de flan pas assez compact

Test n°21 : 
Variable modifiée : crème aux oeufs - pour essayer de rendre le flan plus compact, ajout de 5g de maïzena à la recette de flan aux oeufs (petite portion)

Conclusion : début de texture tranchée / farineuse qui ne résout pas le problème de flan pas assez compact

Test n°22 : 
Variable modifiée : crème aux oeufs - ajout de 0,35g de curcuma pour donner au flan une couleur plus jaune proche du flan classique (petite portion)

Conclusion : flan beaucoup trop jaune et couleur éloignée du flan classique. Grains de curcuma remontant à la surface. Goût du curcuma présent

Test n°23 : 
Variable modifiée : crème aux oeufs - recette du test 17 avec ajout de curcuma (0,35g max) mais moins que le test 22

Conclusion : couleur du flan toujours très jaune, texture inchangée

recette finale 17 réalisée de nouveau

10/09 : Dégustation en aveugle avec questionnaire de test sensoriel en présence d’Appétoque et de l’autre groupe travaillant avec Appétoque. Présentation de 3 flans :

Flan pâtissier classique

Flan sans coloration

Flan avec coloration au curcuma

11/09 : Validation de la recette finale et rédaction des dernières parties du rapport + envoi à Appétoque pour d’éventuelle modifications

18/09 : Rendu du rapport

Sauce végétale à haute valeur nutritionnelle - CasaVeg 1

Projet réalisé en Co-Working avec CasaVeg par :
Développement d’une sauce à haute valeur nutritionnelle à partir de produits végétaux

Cahier de bord Casa Veg’ 1

24/08 : Réunion zoom de présentation de la startup et du projet de développement d’une sauce à haute valeur nutritionnelle, faite à partir de produits végétaux, avec l’équipe de Casa Veg et l’équipe de travail

13/09 : Réunion de réintroduction au sein de la startup pour définir les axes de recherches :

super-aliments : graines de céréales (tournesol, lin, chia), plantes : orties, argousier

Huiles essentielles et hydrolats, eau de cuisson

Produits issus de la fermentation : drèche, levure de bière, tanins

Légumineuses : edamame, chanvre

21/09 : réunion n°1 zoom
Point fait sur les 4 axes de recherches, redéfinition de certaines problématiques. Poursuite des recherches bibliographiques sur ces sources protéiques végétales ou sources bioactives de nutriments.

28/09 : réunion n°2 zoom
Poursuite des recherches et présentation de celles-ci à la startup.

07/10 : réunion n° 3 en zoom,
préparation de la présentation de nos résultats de recherches à la fondatrice de casa Veg’.
→ Mettre les conclusions de la présentation et des pistes présentées : poursuite ou non des recherches des pistes avancées.

27/10 : réunion n°4 en présentiel
→ Préparation d’une présentation pour faire un résumé sur l’état de nos recherches actuelles et faire un point : poursuite ou arrêt des pistes, aspects positifs et négatifs de l’utilisation de ces ingrédients.
→ réunion annulée :( start up n’a pas le temps

04/11 : réunion n°5 en zoom
Fermeture de 3 axes de recherche sur 4 : résumé des recherches faites jusqu’à cette date sur les huiles essentielles et hydrolats, les super-aliments (graines de céréales (tournesol, lin, chia), plantes : orties, argousier et chanvre, edamame).
Poursuite et amélioration de l’axe des produits de fermentation (drèche et levure de bière).
On définit un projet plus précis : développer une pâte qui sert pour la base de la sauce des Green Boc’ Casa Veg’ ou bien pouvant être commercialisée par Casa Veg’ pour d’autres industriels.
Nouvelles recherches à faire sur :

les procédés de fermentation et lactofermentation,

les propriétés organoleptiques et technico physiques de l’oeuf afin de pouvoir le remplacer dans les préparations

matrice protéique des produits de fermentation (drèche, levure de bière)

les champignons locaux (parfois peu connus) riches en protéines avec une matrice intéressante d’un point de vue physique

géographie des ressources possibles

10/11 : réunion n°6 en zoom, avec le groupe mer
Topo fait par la start-up sur le processus de l’innovation, des différentes pistes à aborder lors du mapping (géographie, marché, nutrition, propriétés de l’aliment), les différentes problématiques rencontrées, et les solutions possibles à apporter.
Présentation et mise en pratique de la matrice de calcul de l’indice chimique pour la teneur en acide aminés des sources protéiques trouvées afin de pouvoir les associer dans un plat
Préparation à la réunion de mi-parcours du PST.
→ Définition et répartition des différents nouveaux axes de recherche dans le groupe et poursuite des recherches.

21/11 : Réunion de mi-parcours du projet
Présentation orale de 5min sur l’avancée du projet et des recherches :

introduction de la startup, mise en contexte du projet : adéquation du projet avec les valeurs de la startup : écologie, circuit court, tendance à la consommation du végétal, repas déjà prêts. Composition du plat et de la sauce.

objectifs souhaités et problématiques : envie d’augmenter la valeur nutritionnelle de la sauce pour optimiser les besoins en protéines et en acides aminés essentiels. Par conséquent, la problématique est de trouver les aliments issus du règne végétal, locaux et qui peuvent répondre à la problématique.

différents axes de recherches mis en évidence : les protéines végétales, les graines et oléagineux, les huiles essentielles et hydrolats et enfin les co-produits de fermentation (permettent de limiter le gaspillage en utilisant des co-produits de fermentation souvent jetés et non utilisés).

perspectives et poursuite du projet : poursuite du projet sur l’axe des co-produits de fermentation pour des raisons tendancielles sur le marché, mais aussi écologique avec la revalorisation de produits considérés comme déchets. Objectif de retrouver les propriétés physico-chimiques de l'œuf pour réaliser la constitution de la pâte “universelle” de la sauce à intégrer à plusieurs plats.

Discussion autour du projet : propositions de différentes pistes d’amélioration et de recherches comme les okara de laits végétaux, les champignons séchés, les tourteaux oléagineux (aussi des co-produits d’agriculture à revaloriser), la lactofermentation ou autre types de fermentation.

Avec la startup, redéfinition d’axes de recherches pour la pâte, et poursuite des veilles bibliographiques réalisées.
Objectif : trouver un protocole expérimental à mettre en place pour trouver les meilleures caractéristiques de la pâte.
Recherche des matrices protéiques et en acides aminés des produits pour pouvoir faire les meilleures associations possibles entre les produits et avoir la meilleure composition.
→ Tester les processus de fermentation sur l’okara, le shiitake, les tourteaux : 

seule : produit + eau et sel

avec la méthode de la fermentation du saké

avec ajout de bactéries pour la lactofermentation

28/11 : réunion zoom n°7 : choix des protocoles d’expérimentations
→ Schéma des expériences :

30/11 : réunion zoom n°8
Mise à jour du protocole d’expérimentation :

Fermentation selon les protocoles trouvés pour chaque ingrédient

tourteau de noix

levain de farine de blé (contrôle positif)

levain de tourteaux

sans fermentation (contrôle)

shiitake :

lactofermentation avec lactobacillus

sans fermentation (contrôle)

autre

drèche :

avec ajout de micro organismes (bacillus) qui produisent des enzymes spécifiques capables de dégrader les fibres présentes dans la drèche.

avec ajout d’enzymes spécifiques supplémentaires : laccases ou amylases

sans fermentation (contrôle)

→ avec chacune des 3 conditions de fermentation et de contrôle : réalisation d’un test de Bradford (ou autre test capable de mesurer la teneur en protéine)

Avec le levain de tourteaux de noix : ajout de chaque ingrédient individuellement selon des proportions calculées en fonction de l’indice chimique (pour avoir une complémentarité parfaite de tous les acides aminés essentiels).

→ réalisation d’un test de Bradford pour la teneur en protéines à chaque ajout d’ingrédient (shiitake, drèche, céréale, légumineuse)
→ test organoleptique (texture, goût, couleur…) à chaque ajout d'ingrédients pour adapter les proportions possibles aussi.

+ Trouver le sourcing de tous les éléments nécessaires pour faire les expérimentations

01/12 : Discussion avec la start-up, par soucis de temps et d’approvisionnement, on décide de laisser de côté le tourteau également et de garder la drèche et le shiitake qui sont faciles à sourcer.
Appel avec La Pintine pour parler du projet, ils sont emballés et veulent bien goûter pour éventuellement faire un partenariat avec casa veg.

02/12 : Discussion avec la start-up : pour des raisons économiques, abandon de la fermentation du shiitake avec des souches lactobacillus plantarum et remplacement par une fermentation avec des grains de kéfir d’eau (plus abordable) et par des starter de tempeh.
Nouveau schéma d’expérimentation :

06/12 : discussion avec la startup
Récupération de la farine de drèche en magasin. Pas de farine de drèche disponible dans le point de vente mentionné par La Pintine (font de la farine de drèche dans le 93).
Abandon de la piste de la fermentation de la drèche avec Bacillus Subtilis pour des raisons économique et de temps au niveau logistique des commandes et des durées de livraison. Pour la drèche : fermentation en levain, fermentation avec du kéfir 7%, fermentation tempeh 1% et contrôle sans ajout de souche de fermentation.

07/12 : début de la fermentation de la drèche en levain : 40 g de farine + 40 mL d’eau + 1 càs de miel et 20 g de farine et 20 mL d’eau dans des pots plus petits 1 càc de miel + contrôle positif de levain fait à la farine de blé dans les mêmes conditions (40 g de farine et 40 mL d’eau et 20 g de farine et 20 mL d’eau).
Conservation des levains à température ambiante, et réhydratation chaque jour jusqu’à ce qu’il double de volume.

09/12 : réunion en présentiel à la fac avec la startup et les 2 groupes du projet Casa Veg Terre et Mer.
Revue des différents protocoles prévus, des quantités à utiliser et des différentes conditions et réplicats.

12/12 - 16/12 : Réalisation des différents protocoles de fermentations sur la farine de drèche et le shiitake séché selon les conditions ci-dessus.

13/12 : au Fablab
Mise à fermenter des différentes conditions :

Stérilisation des erlenmeyers utilisés pour la fermentation pendant 5 min dans de l’eau bouillante.

Mixage du shiitake séché jusqu’à obtention de la farine : 3 sachets de 40 g → 120 g de farine obtenue

Mélange de 120 g de farine de shiitake avec de l’eau jusqu’à obtenir la consistance d’une pâte → ajout 800 mL d’eau = poids final : 918,30 g.

Répartition de 35 g de cette pâte dans 9 erlenmeyers (3 réplicats pour les 3 conditions)

Pour la condition kéfir : ajout de 7% de kéfir = 2,45 g de kéfir par erlenmeyer

Pour la condition tempeh : ajout de 1% de tempeh = 0,35 g de tempeh par erlenmeyer

Pour la condition contrôle : pas d’ajout d’agent de fermentation

Fermeture des erlenmeyers avec du papier.

Mélange de 120 g de farine de drèche avec de l’eau jusqu’à obtenir la consistance d’une pâte → ajout de 260 mL d’eau = poids final : 

Répartition de 35 g de cette pâte dans 9 erlenmeyers (3 réplicats pour les 3 conditions)

Pour la condition kéfir : ajout de 7% de kéfir = 2,45 g de kéfir par erlenmeyer

Pour la condition tempeh : ajout de 1% de tempeh = 0,35 g de tempeh par erlenmeyer

Pour la condition contrôle : pas d’ajout d’agent de fermentation

Fermeture des erlenmeyers avec du papier.

⇒ Fermentation pendant 48h (début le 13/12 à 16H)

14/12 : au fablab
Réalisation de la gamme étalon pour la détermination de la teneur en protéines selon la méthode de Bradford :

15/12 : au fablab
Réalisation des tampons pour l’extraction protéique → pas de matériel mis à disposition, donc pas de possibilité de réaliser le tampon en amont.
Mise en trempage des pois chiches pour la cuisson le lendemain.

16/12 : au fablab
Fin des fermentations de 48h pour le shiitake et la drèche. Des contaminations de mycélium présentes dans les conditions de drèche avec du tempeh et dans le contrôle de la drèche → non exploitable.

Réalisation du tampon d’extraction dans la glace : Tampon phosphate 100mM, pH 7,8 + 0,1 mM EDTA + 1,25 mM PEG 4000. Puis ajout DTT
Dans les mortiers : mise de 3mL de tampon d’extraction froid et une pincée de PVP, et broyage rapide avec 1 g de produit de fermentation.
Répartition des broyats dans 2 tubes eppendorf 1,5mL.
Centrifugation 11000 rpm pendant 15 min à 4°C
Récupération du surnageant dans des tubes eppendorf 1,5 mL et conservation dans la glace.

Début d’extraction protéique sur des colonnes Sephadex G25 P10, mais finalement non utilisée :
→ Directement dosage des protéines à partir du surnageant par spectrophotométrie : 
Volume surnageant : 5 µL
Volume d’eau : 795 µL
Volume réactif de Bradford : 200 µL
Réalisation de 2 réplicats pour chaque condition (manque de temps supplémentaire) à une absorbance de 595 nm.
Relevé des DO pour chaque condition.

Cuisson des pois chiche pendant 1h, et du quinoa pendant 15 min.

Réalisation d’une pâte à partir de la meilleure condition de fermentation (celle contenant le plus de protéine), à différentes proportion des mélanges de drèche, shiitake, pois chiche et quinoa :

10% drèche + 15% shiitake + 25% pois chiche + 50% quinoa

10% drèche + 10% shiitake + 30% pois chiche + 50% quinoa

10% drèche + 5 % shiitake + 35% pois chiche + 50% quinoa

21/12 :
Analyse des résultats des DO obtenues pour le shiitake, la drèche et les fermentations.
Augmentation de la quantité en protéine uniquement pour le shiitake avec une fermentation au kéfir par rapport au contrôle. Pas d’augmentation de la teneur en protéine pour la drèche fermentée ni pour le levain.
Possibilité de refaire les relevés de DO et de la gamme étalon à la rentrée pour vérifier les données, car elles ont été réalisées rapidement.

Depuis le 21/12 : rédaction du mémoire.Conservation des algues lactofermentées - CasaVeg 2

Projet réalisé en Co-Working avec CasaVeg par : Flora Desse, Luna Guillon, Lucie Mary, Estelle Pires
Détermination de la valeur nutritionnelle de différentes algues lactofermentées aux grains de kéfir

PROJET SCIENTIFIQUE ET TECHNIQUE
“Nutrition and Health”

Septembre 2022 - Janvier 2023

CARNET DE BORD

Start-up Partenaire : Casa Veg’ 

Présenté par 
Flora DESSE, Luna GUILLON, Lucie MARY & Estelle PIRES
 
Master de Sciences et Technologies
Mention Biologie Intégrative et Physiologie
Parcours-type : Nutrition, Qualité et Santé

Responsables du parcours : Pr. Véronique Béréziat & Pr. Khadija El Hadri-Zegouagh
Représentants de la BU : M. Julien Prost et Mme. Lorette Bonnetain
24 août 2022 Première prise de contact avec Odile Castagné (créatrice de la start-up) et Hélène Vanlerberghe (alternante, ancienne M2 NQS) via zoom.

Présentation de la start-up et du projet

7 sept. 2022 Rencontre physique au centre où se trouve la start-up avec Odile Castagné et Hélène Vanlerberghe.

Discussion autour du projet : définition des axes de recherche

Premiers axes de recherche : Histoire de la consommation des algues - La filière algues en France et dans le Monde - Les algues bretonnes - Les algues méditerranéennes 

8 sept. 2022 au 14 sept. 2022 Recherches bibliographiques sur nos axes de recherche. 

Préparation d’un compte-rendu avec : “Executive Summary” et détails pour chaque axe. Le CR est envoyé la veille de la réunion à Hélène Vanlerberghe et déposé sur un drive partagé

15 sept. 2022 Réunion avec Hélène Vanlerberghe via zoom. 

Discussion autour de nos recherches

Orientation vers d’autres axes (La composition des algues - Le régime méditerranéen - Le régime d’Okinawa - Le pouce-pied) et approfondissements des premiers

16 sept. 2022 au 28 sept. 2022 Recherches bibliographiques sur nos axes de recherche. 

Préparation d’un compte-rendu avec : “Executive Summary” et détails pour chaque axe. Le CR est envoyé la veille de la réunion à Hélène Vanlerberghe et déposé sur un drive partagé

29 sept. 2022 Réunion physique avec Odile Castagné et Hélène Vanlerberghe. 

Discussion autour de nos recherches

Orientation vers d’autres axes (L’iode - La lactofermentation - Profils en acides aminés des algues - Les plantes marines - Etang de Thau) et approfondissements des autres

30 sept. 2022 au 5 oct. 2022 Recherches bibliographiques sur nos axes de recherche.

Préparation d’un compte-rendu avec : “Executive Summary” et détails pour chaque axe. Le CR est envoyé la veille de la réunion à Hélène Vanlerberghe et déposé sur un drive partagé

6 oct. 2022 Réunion avec Hélène Vanlerberghe via zoom.

Discussion autour de nos recherches

Définition des axes à présenter sur un Powerpoint pour la prochaine réunion

Approfondissements des axes : Algues en Bretagne et Méditerranée - Conservation des algues - Lactofermentation

7 oct. 2022 au 25 oct. 2022 Recherches bibliographiques sur nos axes de recherche et préparation de la présentation Powerpoint pour la prochaine réunion. 

Préparation d’un compte-rendu avec : “Executive Summary” et détails pour chaque axe. Le CR est envoyé la veille de la réunion à Hélène Vanlerberghe et déposé sur un drive partagé

Préparation d’une présentation Powerpoint sur les axes : Histoire de la consommation des algues (utilisation ancestrale en Asie, place des algues en France, régime nordique) - La filière des algues (principaux usages des algues en France, projet “porphyra”, benchmark des fournisseurs) - La sélection des algues (tableau des qualités nutritionnelles des algues déshydratées, comparaison algues déshydratées vs. fraîches, recettes, comparaison régimes méditerranéen et Okinawa, algues et plantes de Méditerranée, étang de Thau, spiruline)

26 oct. 2022 Réunion physique avec Odile Castagné et Hélène Vanlerberghe. 

Présentation du Powerpoint et discussion autour de nos recherches

10 nov. 2022 Réunion avec Hélène Vanlerberghe + groupe Terre via zoom.

Mise au point calcul de l’indice chimique

Présentation “Innover en alimentaire”

Discussion autour de la réunion de mi-parcours du 21 nov. 2022 avec l’équipe pédagogique du master

11 nov. 2022 au 20 nov. 2022 Recherches bibliographiques sur nos axes de recherche et préparation de la réunion de mi-parcours.

Recherches sur : mélange de paillettes d’algues avec légumineuses et oléagineux

Recherches sur : conservation des algues fraîches et déshydratées

Recherches sur : la lactofermentation des algues

Recherches sur : profils en acides aminés de la spiruline

Préparation des informations et du diaporama pour la réunion de mi-parcours

21 nov. 2022 Réunion de mi-parcours au Fablab de SU en présence d’Hélène Vanlerberghe, Odile Castagné (CasaVeg’) et Khadija El-Hadri, Christophe Bailly, Isabelle Guillas (équipe pédagogique du master).

Présentation de 5 min : CasaVeg’ - Problématique et Objectifs - État d’avancement - Perspectives

Discussion : demande de précisions sur la présentation de la startup, contact Algorapolis (producteur de spiruline à Paris), précision sur la pollution des algues, précision sur les bienfaits des algues, précision sur l’explication de l’intégration des algues au plat

21 nov. 2022 Réunion rapide de débrief post-mi-parcours et prochains objectifs avec Odile Castagné et Hélène Vanlerberghe + groupe Terre.

Poursuite des recherches sur les procédés d’optimisation de la biodisponibilité des nutriments dans les algues

Programmation d’une réunion le 28 nov. 2022 pour présenter le plan expérimental

22 nov. 2022 Recherches bibliographiques. 

Recherches sur : biodiversité des algues et intérêt écologique de l’aquaculture intégrée

Calculs des indices chimiques et complémentarité en acides aminés algues/légumineuses/céréales

Recherches sur : le profil en acides aminés de l’oeuf, l’utilisation de l’oeuf en cuisine, les substituts de l’oeuf

Recherches sur : fournisseurs de spiruline le plus près possible (abandon Algorapolis → liquidation judiciaire)

Recherches sur : la crise marine

22 nov. 2022 Point téléphonique avec Hélène Vanlerberghe en fin de journée (Estelle Pires). 

Faire le calcul des proportions légumineuses/céréales/algues : quelle quantité d’algues à mettre pour compenser les manques ?

Essayer de trouver un producteur de spiruline au plus près de Paris : partir de Paris et élargir le périmètre petit à petit

Trouver les conditions de culture de la spiruline pour savoir si on peut en faire nous-mêmes

La criste marine a-t-elle un effet sur la santé ? Est-elle intéressante dans l’écosystème ?

Réfléchir à la mise en place de tests organoleptiques

23 nov. 2022 Recherches bibliographiques. 

Recherches sur : pollution et toxicité des algues (risques chimiques)

Recherches sur : les légumineuses et céréales utilisées chez CasaVeg’

Recherches sur : l’utilisation des algues comme substrat de fermentation, les conditions optimales de fermentation des algues,

Poursuite des recherches sur : la criste marine

Recherches sur : les conditions de culture de la spiruline

Premier appel avec le contact de Bord à Bord fourni par Odile Castagné : pas de réponses mais direction vers d’autres contacts

23 nov. 2022 Point téléphonique avec Hélène Vanlerberghe en fin de journée (Luna Guillon). 

Abandon de la criste marine

Comment améliorer la qualité de la spiruline ?

Recherches sur l’association entre algues et okara

Les algues qui nous intéressent sont-elles produites en aquaculture intégrée ?

La texture "gluante" de l’algue réhydratée peut être intéressante

24 nov. 2022 Recherches bibliographiques.

Recherches sur : pollution et toxicité des algues (risques microbiologiques et physiques)

Recherches sur : la lactofermentation des algues et des légumes, les bienfaits de cette lactofermentation

Mise en place de protocoles de fermentation : avec sel uniquement, avec des grains de kéfir

Second appel avec Bord à Bord : peu de réponses, demande de poser les questions par mail → envoi du mail avec l’ensemble des questions, notamment la demande des fiches techniques des algues 

Recherches sur : régime danois → 5g d’algues/jour seulement à cause de la concentration en iode 

25 nov. 2022 Point téléphonique avec Hélène Vanlerberghe en début de journée (Lucie Mary). 

Trouver des informations sur la ferme à spiruline proche de Cherbourg

Trouver un pourcentage de sucre présent dans les algues suffisant pour la fermentation

Mettre en place le plan expérimental pour le GreenLab : que teste-on et pourquoi ? Quelles conditions ?

25 nov. 2022 Recherches bibliographiques.

Réponse au mail : réponses obtenues pour quelques questions, pas de fiches techniques disponibles donc pas de valeurs de concentrations pour les différents acides aminés des algues proposées

En Bretagne : culture de wakamé et laitue de mer, pour le reste il s’agit d’algues sauvages cueillies à la main

Des analyses de contamination des algues sont réalisées et publiées régulièrement

Fermentation avec grains de kéfir sans sel possible

25 nov. 2022 Point téléphonique avec Hélène Vanlerberghe en fin de journée (Flora Desse).

Qu’est-ce qui permet à un ingrédient d’être fermentescible ? Quelle est la différence entre les ingrédients fermentescibles et non fermentescibles ?

Poursuivre le plan expérimental pour la réunion du 28 nov. 2022

28 nov. 2022 Réunion avec Odile Castagné et Hélène Vanlerberghe via zoom.

Présentation de l’avancement des recherches à Odile Castagné

Présentation des protocoles de fermentation des algues : avec sel uniquement, avec grains de kéfir et avec L.plantarum

Procédé de lactofermentation des algues par grains de kéfir → validé comme innovant 

Explication de la pâte à développer : mélange de 3 éléments dont l’algue pour former une pâte utilisable pour former à la fois une sauce et à la fois un aliment solide (ex. falafel)

Faire une fiche technique d’élaboration de la pâte : établir un trio, les temps de cuissons et les procédés à mettre en place

29 nov. 2022 au 30 nov. 2022 Recherches et mise en place de la fiche technique. 

Sélection de 3 trios pour la pâte : spiruline/okara de soja/quinoa, spiruline/okara de soja/riz blanc, spiruline/okara de soja/sarrasin, laitue de mer/okara de soja/sarrasin

Protocoles de fabrication de l’okara (pour la pâte) et du lait de soja (pour la sauce)

Protocoles de fermentation de la laitue de mer (avec sel, grains de kéfir et L.plantarum)

Sourcing des fournisseurs de chaque ingrédient

Idées de recettes : sauce avec mélange pâte + lait de soja ; boulette type “arancini” marin

1 déc. 2022 Réunion avec Hélène Vanlerberghe en début de journée via zoom.

Abandon de l’okara → trop peu intéressant face aux autres légumineuses 

Sélection des trios : spiruline/pois chiches/riz brun et laitue de mer/pois chiches/riz brun

Faire les calculs d’indices chimiques des duos : algue/pois chiches et algues/riz brun

La fermentation est-elle possible sur la spiruline déshydratée → réhydratée ? 

Etablir le schéma des expériences : résumé visuel

1 déc. 2022 Recherches, calculs et réalisation des schémas d’expériences.

Evaluation des complémentarités entre algue/pois chiches et algues/riz brun

Fermentation sur spiruline déshydratée → réhydratée validée 

Recherches sur : lactofermentation par L.plantarum → problématique de conditions de culture trop contraignantes 

Discussion avec Hélène de la fermentation via des starter de tempé

Mise au point et envoi des schémas d’expérimentations suivant :

2 déc. 2022 Rédaction de la nouvelle fiche technique. 

Protocoles de fermentation de la laitue de mer et de la spiruline aux grains de kéfir (3 conditions)

Protocoles de fermentation de la laitue de mer et de la spiruline aux starter de tempé (3 conditions)

Protocole de mesure de la concentration protéique des algues (méthode de Bradford)

Recette pour la pâte (différents mélanges)

Questionnaire organoleptique

13 déc. 2022 au 16 déc. 2022 Expérimentations au Greenlab de Sorbonne Université

13 déc. 2022 Lancement des fermentations pour 48h d’incubation.

Formation des pâtes d’algues : 100g de spiruline en poudre + 220 mL d’eau de source et 100g de laitue de mer fraîche + 200 mL d’eau de source 
Fermentation des pâtes de laitue de mer et de spiruline aux grains de kéfir (x3)
Fermentation des pâtes de laitue de mer et de spiruline aux starter de tempé (x3)

14 déc. 2022 et 15 déc. 2022 Passage au GreenLab pour surveiller les fermentations et préparer les tampons d’extraction des protéines.

Fermentation : 24h 

Fermentation : 48h

16 déc. 2022 Arrêt des fermentations, extractions des protéines et dosages des protéines par la méthode de Bradford + analyses organoleptiques des pâtes.

Extraction des protéines par broyage pour toutes les conditions
Mesure de la concentration protéique des algues (dosage via la méthode de Bradford) 
Préparation de la pâte avec riz basmati complet et pois chiche
Questionnaire organoleptique

Arrêt des fermentations et extractions des protéines par broyage 

Mesure de la concentration protéique des algues via un dosage par la méthode de Bradford 

Préparation des pâtes algues/riz basmati complet/pois chiches + analyses organoleptiques 

17 déc. 2022 au 18 janv. 2023 Rédaction et envoi du mémoire ainsi que de ce carnet de bord + préparation de la soutenance orale du 26 janv. 2023.

Analyses statistiques des résultats des dosages protéiques : la fermentation de la spiruline en poudre par les grains de kéfir augmente significativement la concentration protéique de la cyanobactérie. Les autres résultats ne sont pas significatifs.

26 janv. 2023 Soutenance orale du projet en présence d’Odile CASTAGNE et Hélène VANLERBERGHE (startup Casa Veg’) et Véronique BEREZIAT et Christophe BAILLY (rapporteurs et membres de l’équipe pédagogique). 

FIN DU PROJET. 

Kombucha de fruits - Archipel

Projet réalisé en Co-Working avec Archipel par : Juliette Bayot, Karen Kayat, Jade Abittan, Aleksandar Mitrovic, Lucie Poupineau
Réalisation d'un kombucha sans thé, bio, local et de saison

NOVEMBRE : 
LUNDI 14 

Réalisation de kombucha à partir de feuilles de framboisier, verveine, thé 

MERCREDI 16 

Vérification du pH 

VENDREDI 18 

Vérification du pH 

JEUDI 24 

Réalisation d’une deuxième production de kombucha à partir de feuilles de framboisier, verveine et thé en duplicats. Augmentation de la durée d’infusion de 10 minutes pour les feuilles de framboisier et verveine

Prise du pH J-0

LUNDI 28
Pour la première production de kombucha: J-14

Vérification du pH

Titrage d’acidité (mesurer l’acidité totale)

Suivi de l’alcool (distillation fractionnée + mesurer le taux d’alcool)

Pour la deuxième production de kombucha: J-4

Vérification du pH

DÉCEMBRE :

Rédaction du mémoire

JEUDI 1er
Deuxième production J-7:

Vérification du pH

Titrage d’acidité (mesure de l’acidité totale)

JEUDI 8
Pour la deuxième production de kombucha: J-14

Vérification du pH

Titrage d’acidité (mesurer l’acidité totale)

Suivi de l’alcool (distillation fractionnée + mesurer le taux d’alcool)

JANVIER :

Rédaction du mémoire 

MARDI 10

Réalisation d’une dernière production de kombucha à partir de feuilles de framboisier et de verveine

Prise du pH

MERCREDI 18

Mise en bouteille des kombuchas réalisés le 10/01

🧫 UE 564 démarche expérimentale (Bio)



Quels sont les effets d'une induction d'oestrogène et de progestatif de synthèse sur le comportement et la survie du gammare ?

Le contexte de notre expérience :
L'échec du nano-plastique :
Notre premier sujet ne se concentrait pas sur la pollution des rivières aux hormones sexuelles mais sur la fragmentation du microplastique de polyéthylène en nanoplastique par les gammares de l'Oise. Notre question s'originait dans l'article suivant : https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7393071/ Les auteurs remarquent qu'une espèce de gammare : Gammarus duebeni, est capable de fragmenter le microplastique (polyéthylène) en nano plastique. Ce phénomène pose des enjeux environnementaux importants car le nano plastique est toxique et peut s'infiltrer dans les cellules.Après avoir commencé à mettre en place le plan expérimental et fais des recherches sur les gammares (ou les pécher, comment les stocker et les maintenir en vie les temps de l'expérience...) nous avons abordé plusieurs questions pratiques concernant les techniques de mesures de la quantité de plastique à la fin de l'expérience. Ce point a été le premier problème dans la mise en place de notre plan expérimental car nous avions plusieurs idées en théorie (utiliser un filtre à nano ou micro particules, observation après évaporation ou centrifugation), mais dont nous ne connaissons pas l'efficacité. De plus nous n'étions pas sûr d'avoir le matériel nécessaire au greenlab. Pour tester nos techniques, il a fallu produire nous même le microplastique. Pour cela, nous avons découpé à la main le haut de bidons de polyéthylène (que nous réutiliserons plus tard pour notre expérience sur les hormones sexuelles stéroïdiennes) avant de les broyer. Pour faire cela, nous comptions utiliser un ultra-turax, qui fut un échec. N'ayant pas réussi à produire du micro plastique ni à répondre à toutes nos problématiques et ayant déjà perdu du temps, nous avons décidé de modifier notre sujet pour s'intéresser à l'effet d'hormones sexuelles (œstrogène + progestatif de synthèse) sur le comportement d'une population de gammares de l'Oise.
Plan expérimental :
Nous utilisons des pilules contraceptives de concentration de 30 microgrammes d'oestradiol par pilule. La concentration d'œstradiol dans chaque cuve est la variable indépendante de nature quantitative discrète. 3 conditions expérimentales sont testées : - Contrôle : aucune modification des paramètres - Low : Faible concentration d'oestradiol (7,5 microg/L soit 1/2 pilule par cuve) - High : Forte concentration d'oestradiol (75 microg/L soit 10x plus soit 5 pilules par cuve) Chaque condition est répliquée 6 fois, nous avons donc un total de 18 cuves. O utre la concentration d'oestradiol  elles ont toutes les mêmes paramètres :-2L d'eau d'Oise -Oxygénation par bulleur - 6 gammares ( 4 choisis aléatoirement et 1 couple présentant un comportement pré-copulatoire : gammare mâle intelligent au dos d'une femelle) -3 granules broyées de nourriture pour crevette
Les cuves sont disposées de sortes à ce qu'aucune ne soit à côté d'une condition similaire afin de randomiser et d'éviter que les facteurs extérieurs n'influencent uniquement les cuves d'une condition, induits par une fenêtre (lumière et aération ) et une porte (présence humaine)

Nous avons fait un relevé de résultats à 3 reprises, chacune espacées d'une semaine et sans condition modificatrice à part le rajout de nourriture. Cela nous permet d'observer l'évolution de la modification du comportement des gammares au cours du temps. Dates des relevés : 24/11, 01/12, 08/12
Nous observons 3 variables dépendantes  -Survie des gammares (quantitative discrète ) -Temps de comportement pré-copulatoire ( quantitative continue ) -Mobilité ( quantitative discrète )
Protocole :
Préparation de l'expérience :
Pour commencer, nous avons pêché les gammares dans l'Oise à Orry-la-Ville et nous avons récupéré l'eau (18 L pour les cuves + quelques litres en plus pour réaliser les mesures). Nous avons utilisé 18 bidons de polyéthylène de 5L pour en faire des cuves. Pour cela, nous avons coupé le haut. Puis nous avons rempli ces cuves de 2L d'eau de l'Oise chacune et nous les avons disposées (voir schéma du plan expérimental). Afin d'oxygéner les cuves, nous avons réalisé un montage en série avec des bulleurs cylindriques. Les gammares ont été répartis aléatoirement dans les cuves, avec 6 gammares par cuve dont un couple. Nous les avons nourris avec de la crevettes pour nourriture et nous avons ajouté les pilules : une demi pour les cuves condition Low et 5 pour les cuves condition High.

Afin qu'elles puissent être réduites dans l'eau des cuves, nous avons broyés chacune de pilules en fine poudre à l'aide d'un mortier que nous avons rincé à l'eau claire entre chaque cuve.
Pilules contraceptives pour la condition High, avant et après broyage par un mortier
Mesures :
Nous avons réalisé les mêmes mesures à trois reprises : le 24 novembre et les 1er et 8 décembre. Nous avons à chaque fois compté le nombre de gammares morts par cuves, ainsi que le nombre de couples, c'est-à-dire les gammares qui sont associées ensemble. Pour filmer les déplacements, nous avons utilisé 6 boîtes en verre plastifié de 15×15 cm. Sous ces boîtes, nous avons placé du papier quadrillé avec des carreaux de 1×1 cm (technique provenant de Vellinger et al. 2012). Nous avons rempli les boîtes avec 100 mL d'eau de l'Oise que nous avions en plus. Nous avons transféré les gammares de 6 cuves dans les boîtes, tout en gardant la même répartition que dans les cuves. Nous les avons agités avec une baguette en bois le plus rapidement possible afin qu'ils ont subi les mêmes perturbations puis nous avons attendu 1 minute avant de commencer l'enregistrement. Chaque vidéo dure 1 minute. Nous avons refait la même chose à 2 reprises pour avoir toutes les cuves. Nous avons ensuite regardé les vidéos et compté le nombre de carreaux que chaque gammare traverse en prenant un point de repère sur le corps du gammare.

Dispositif de prise de mesures de la mobilité des gammares pour 6 cuves
Journal de bord :
Rapport du 6/10/2022 et 12/10/2022 - 1ère et 2ème séances en groupe Nous avons défini les enjeux de notre premier plan d'expérience sur la dégradation du micro plastiqué en nano. Nous avons aussi des recherches sur le mode de vie et la biologie des gammares : Les gammares vivent en eau douce pour la plupart des espèces, dans des eaux entre 2 et 20°C. Ils supportent bien les changements de pH (entre 4 et 9,9) et la pollution dans une certaine mesure. En revanche, ils ont besoin d'une eau bien oxygénée. Ils se nourrissent de détritus organiques ou bien inorganiques, dont notamment des feuilles mortes. Les juvéniles peuvent aussi être cannibales s'ils n'ont pas assez de nourriture. La reproduction à lieu toute l'année, chaque femelle peut avoir jusqu'à 6 "portées" par an. Les juvéniles sont la forme majoritaire toute l'année, leur croissance dure 2 à 3 semaines l'été, elle est ralentie en hiver. L'espérance de vie des gammares est entre 1 et 2 ans. La densité est maximale en septembre puis décroît pour atteindre la minimale en février-mars. Cela pose une limite : il ne faut pas trop tarder avant d'aller nous procurer nos gammares. Enfin nous avons déterminé le lieu de pêche : Le lavoir d'Orry-La-Ville en Picardie, alimentées par l'Oise.
Rapport du 20/10/2022 Nous sommes rendus compte que notre expérience était bien trop compliquée à mener avec nos moyens et nos délais, donc nous avons dû modifier notre problématique. Nous avons dépassé la majorité de la séance à réfléchir à de nouvelles problématiques, mais qui pourraient toujours se concentrer sur la pollution aux microplastiques des rivières. Nous avons reçu notre matériel :-18 cuves dans lesquelles nous allons contenir nos gammares-Des bulleurs que nous allons monter en série
Rapport du 27/10/2022 Thomas est allé faire du repérage et récupère des gammares dans le lavoir le matin même. Au Fablab nous avons découpé transversalement le haut de nos 18 cuves, broyer les morceaux de polyéthylène ainsi récupérés, puis grâce à l'ultra turax on créer des micro plastiques entre 20 et 40 microm (pour qu'ils passent dans nos filtres). Malheureusement l'ultra turax n'a pas fonctionné sur nos plastiques. Fautes de moyen nous avons du passer à notre plan de secours et décider d'une autre problématique
Nous nous interessons maintenant à l'effet d'une forte quantité d'œstrogène sur une population de gammares. On en retrouve dans nos rivières à cause de la pollution par le rejet de pilules contraceptives et par nos urines. Chez les poissons, cette hormone entraîne des phénomènes de féminisation. Moins d'études ont été accordées quant à son effet sur les arthropodes mais on peut hypothétiser qu'il y en a et c'est ce que nous allons chercher à prouver.
Rapport du 27/10/2022 Nous nous sommes rendus au greenlab pour vérifier que les gammares péchées par Thomas étaient toujours vivantes. Nous avons observé leur comportement (comportement pré-copulatoire, présence de nouvelles larves, comportement d'accrochages ...) et j'ai testé les protocoles (quelle taille de quadrillage ressort le mieux à la vidéo, plutôt utiliser un quadrillage ou une alerte graduée pour la mesure en hauteur, les vidéos filmées au téléphone sont elles exploitables..)Après tous ces tests, nous avons découvert que l'expérience et la prise et l'analyse de données étaient réalisables.
Rapport du 17/11/2022 Lucie, Thomas et Hugo se sont donnés rendez-vous le matin pour prendre le ter vers la picardie : direction le lavoir ! Nous sommes partis avec 9 bidons de 5L, que nous avons chacun remplis d'eau du lavoir. Cela nous fait donc un total de 45L. Pour remplir nos 18 cuves de 2L il nous faut 36L, ce qui nous laisse 9L de côté pour les rinçages et les mesures.A l'aide  d'épuisettes nous avons péchés les gammares. Ce n'étais pas difficile car une fois que nous retournions les feuilles mortes au fond du lavoir (profondeur de 30cm environ) des gammares par dizaine s'activaient. Il nous fallait un total de 108 gammares pour nos expériences. Afin d'en avoir de côté si il y avait des morts pendant le transport, des parasités etc nous en avons péché environ 160. Nous les avons entreposé dans 4 bidons différents pour éviter les problèmes de densité. Nous devions prendre le ter en fin de matinées pour ramener nos gammares au campus pierre et marie curie, cependant tous les transports ont été interrompus, nous sommes restés bloqués et arrivés sur paris qu'aux environs de 21h. Nous avons entreposés les bidons chez Thomas pour la nuit.
Capture de gammares au lavoir d'Orry-la-ville

Rapport du 18/11/2022Nous avons ramenés les bidons au campus et disposés les gammares dans les 18 cuves. Aucune gammare n'est mort durant le transport (yes !). Nous avons pu lancé le protocole : broyer les pilules et les introduire dans les cuves High et Low. Nous avons aussi nourris nos gammares à l'aide de granules pour crevettes, elles aussi broyées au mortier.
26/11/2022, 01 et 08/12/2022Nous avons fait les mesures de résultats selon le protocole détaillé plus haut
Mois de décembreNous avons analysé les vidéos afin de créer notre jeu de donnée pour les analyses statistiques

TRUCS A SUPP
Notre question s'origine dans l'article suivant : https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7393071/ Les auteurs remarquent qu'une espèce de gammare : Gammarus duebeni, est capable de fragmenter le microplastique (polyéthylène) en nano plastique. Ce phénomène pose des enjeux environnementaux importants car le nano plastique est toxique et peut s'infiltrer dans les cellules. La séance du jour nous a permis de poser les principaux enjeux de notre sujet. Gammarus duebeni est une espèce que l'on retrouve plutôt en Irlande et dans une moindre mesure dans les eaux douces britanniques. Nous nous demandons donc si ce phénomène de fragmentation peut se retrouver chez d'autres espèces de gammares en Ile-de-France ou dans les environs.
Pour tester notre hypothèse, nous avons décidé de réaliser une expérience. Bien que pour le moment encore en cours de réflexion, nous réussirons à introduire des gammares dans une cuve d'eau douce et leur donner du microplastique pendant une certaine durée puis doser le nano plastique ou microplastique par la suite. Afin de réaliser notre expérimentation, nous suivrons plusieurs indications dans l'article cité plus haut. Plusieurs problématiques se déclinent de suite : - Les auteurs de l'article indiquent avoir cherché au sein même des organismes la présence de nano plastique, ce qui peut laisser entendre que ces particules restent piégées dans les paroisses digestives des gammares. Ceci est à prendre en compte pour une analyse correcte de nos particules.Nous avons pensé à doser la présence de nano plastique dans l'eau, hors peut-être que nous n'aurons rien si on ne prend pas en compte le fait que le plastique peut encore résider dans les gammares. Pour cela, au moins deux possibilités sont avancées : mesurer microplastique et nano plastique et en faire le rapport afin de voir s'il manque de la matière, ou bien lyser les gammares à la fin de l'expérience pour récupérer le nano plastique (nous n'avons pas encore trouvé comment faire cela). - Il y a une grande diversité de classification du microplastique et nano plastique vis-à-vis des tailles que cela représente. Nous allons surement nous référer à la classification utilisée dans l'article pour nos mesures.- Nous ne connaissons pas la dynamique du micro- et nano plastique dans l'eau, est-ce que cela se sédimente rapidement ? Cela dépend par ailleurs de l'induction ou non d'un courant dans la cuve pour gammares. De plus, on ne sait pas comment le plastique va réagir et s'agréger à la matière organique générée par les gammares.
L'expérience :
Pour notre expérience, nous avons au moins 3 conditions différentes à réaliser : - Contrôle 1 : eau douce sans gammares - Contrôle 2 : eau douce issue du lieu de capture de gammares sans gammares - Condition 1 : eau douce issue du lieu de capture de gammares avec gammares
Le contrôle 2 a pour objectif de vérifier que c'est bien la présence de gammares qui permet la fragmentation du microplastique et non des micro-organismes ou des conditions spécifiques de l'eau. Le contrôle 1 permet de vérifier, dans le cas ou le contrôle 2 et la condition 1 montre toutes deux que le plastique est fragmenté, que l'eau ne permet pas seule de fragmenter le plastique (auquel cas, on montrera alors le rôle prépondérant de l'eau douce issue du lieu de capture de gammares dans le processus de fragmentation). Il pourra exister d'autres hypothèses concernant ce résultat : protocole exp., matériel ou utilisé autre.. Le nombre de réplicats est encore indéterminé, de même que la réalisation dans le temps des manipulations.Selon nos connaissances actuelles, nous pouvons réaliser une condition d'une durée de 4 jours - temps donné par l'article auquel nous nous référons. On peut donc choisir de réaliser toutes les conditions en même temps, sachant que cela peut poser un problème à la fin des 4 jours lorsque nous aurons toutes les manipulations à faire pour doser le plastique.
Dans tous les cas, il nous semble important d'essayer rapidement des manipulations autour du microplastique pour, lorsque l'expérience commencera, être confiant sur la méthode que nous aurons choisie pour le mesurer. Il faut donc prévoir d'acheter du microplastique (polyéthylène ?) rapidement.

Pour la semaine prochaine :
Notre groupe étant composé de 5 personnes, nous sommes répartis les recherches autour du sujet. 1. Le mode de vie des gammares  2. Le plastique et sa dégradation 3. Le repérage des lieux pour capturer les gammares 4. La logistique autour de notre expérimentation 5. La gestion d'un planning pour réaliser l'expérience 6. Le plan d'expérience/protocole
L'ensemble des informations sera ici ajouté. Il semble aussi important de se fixer la semaine prochaine sur la forme de la cuve et sa fabrication pour essayer rapidement de mesurer le microplastique dans un environnement qui sera proche - voir identique - à celui que nous utiliserons au cours de l'expérimentation. De même, il serait utile de se fixer un délai pour réaliser l'expérience afin d'avancer à la bonne vitesse.
Le plastique et sa dégradation
La première question à laquelle répondre est le choix du plastique à utiliser. Dans l'expérience de l'article dont nous nous inspirons, le plastique utilisé est le polyéthylène car il s'agit de l'un des polymères les plus courants dans les produits de soins personnels et, par conséquent, dans les systèmes aquatiques (par la pollution). De plus il est probable qu'il soit consommé par les gammares car sa densité et inférieure à celle de l'eau, il flotte donc en surface, et les gammares sont capables de  collecter de la nourriture à la surface de l'eau, y comprend des lentilles d'eau flottantes.Nous avons donc décidé d'utiliser aussi ce plastique, quant à la taille des morceaux à introduire dans les cuves il s'agirait d'éléments de 15 à 40 micromètre de diamètre. pour nous en fournir nous comptons soit sur : -Nous en fournissons directement au fablab -Acheter un rouleau sur internet puis le découper nous même grâce à une micro broyeuse -Ou grâce à une ponceuse suivi d'un tri par filtre pour ne sélectionner que les tailles qui nous intéressent
Techniques de mesures de la quantité de plastique à la fin de l'expérience : Nous sommes passés par différentes idées, pour compter/déterminer la quantité de nano ou micro plastique à la fin de l'expérience et ainsi conclure sur la question de la fragmentation du microplastique par nos gammares. Dans tous les cas, nous souhaitons faire des observations au microscope pour avoir un support visuel sur lequel se baser. Il faudra aussi faire des études statistiques. Nous pensons aussi pouvoir colorer les microplastiques afin de faciliter l'observation, notamment si nous faisons une lyse des gammares
-Filtre à nano ou micro particules. On prélève des petits volumes d'eau de la cuve qu'on filtre puis on compte/pese la quantité de fragments trouvés et on compare à ce qui a été introduit initialement. -Evaporation : On prélève v puis on fait s'évaporer l'eau : il reste les micro et nano plastiques et dedans on mesure la masse / compte + obs microscope. Si il ya des fragmentations on observe un plus grand nombre de fragments et ils seront plus petits -Centrifugation : On prélève v et on fait centrifuger : dans le culot il y aura des micro et dans le surnageant de nano -> facilite le comptage

La logistique autour de notre expérimentation
Taille et fonctionnement des cuves : 2L avec bulleur pour oxygéner les cuves (montage en série pour utiliser moins de bulleur) Faire du microplastique : Ultra turax pour "mixer" à haute vitesse le plastique et obtenir des micro particules (mais taille non contrôlable) ou utiliser une ponceuse pour avoir de la "poussière" de plastique qui fera office de micro particules (mais pareil, taille incontrôlable) Transport et stockage des gammares : Transport dans des bouteilles en plastique transparentes industrielles contenant l'eau du milieu de l'organisme et dépôt des gammares le plus vite possible dans les cuves sur le campus Pierre et Marie Curie.Prévoir, en plus, des bouteilles contenant uniquement l'eau du milieu où évolue l'organisme pour ne pas manquer de liquide dans les cuves Nourriture pour gammares : gammares --> détritivores --> nourriture pour poisson/crevettes suffira
Gestion d'un planning pour l'expérimentation / protocole / plan d'expérimentation

Suite à divers échanges et réflexions, nous sommes en train de construire le plan d'expérimentation (qui doit être fini pour le 20 octobre). Il est préférable pour des questions pratiques, et de maximisation de la randomisation, de réaliser notre expérimentation en plusieurs temps successifs tout en conduisant nos différentes conditions en parallèles. Nous avons 3 conditions (4 si nous décidons de tester une condition contrôle en plus : a savoir eau claire + gammare sans introduction de plastique - dans le but de vérifier que les gammares ne rejettent pas naturellement du nano plastique dans l'environnement). La durée d'une condition est de 4 jours (l'intervalle entre les mises en place des 4 jours d'expérimentation est nommé rotation).Nous allons donc réaliser une fraction de chaque condition en parallèle des autres, et de répéter ces fractions tous les 4 jours jusqu'à avoir assez de mesures pour une analyse statistique viable.
Si l'on souhaite réaliser 15 répétitions de chaque conditions, on se retrouve à 15x3 ou 15x4 : soit 45 ou 60 mesures au total. Dans le cas des 3 conditions, nous aurions besoin idéalement de 15 cuves pour gammares. On peut alors faire 5 mesures par condition en parallèle et réaliser ainsi l'expérience en 3 rotations soit 12 jours au total. Dans le cas des 4 conditions, nous aurions besoin idéalement de 16 cuves pour gammares. On peut alors faire 4 mesures par condition en parallèle et réaliser ainsi l'expérience en 4 rotations soit 16 jours au total.

Sachant qu'il nous faudra randomiser à la fois les emplacements des conditions à chaque rotation et les expérimentateurs venant s'occuper des gammares et des cuves vides.
Globalement, il reste la question des gammares : - Doit-on les chercher à chaque rotation dans la rivière ou bien les stocker en attendant leur mise en cuve ? Il semble que dans les deux cas, cela pose des limites concernant l'interprétation des résultats. La solution la plus pratique est tout de même le stockage. Il faut par ailleurs faire attention à la possible présence d'un parasite du gammare, et qui réduit son ressentiment. - Combien de fois les nourrir avant les 4 jours, combien de fois par jour ? On note ici une information encore jamais explicite dans le document : les gammares, une fois l'expérience acquise (donc durant les 4 jours d'expérimentation) ne sont pas nourries.Le début de l'expérimentation est consécutif à une induction de microplastique de type polyéthylène dans toutes les cuves.

Rapport du 24/11/2022
Après réflexion, on va mesurer :

Mobilité en longueur : on pose chaque lot de 5 individus sur une feuille quadrillé, on filme leurs mouvements et on compte le nombre de fois qu'ils changent de carreaux. On fait qql secondes de vidéos et plusieurs répliques pour chaque vu. On capturera 30 secondes de vidéos pour chaque cuve s'il y a beaucoup de mouvement durant la prise ou alors 1 minute si les gammares ne bougent pas beaucoup.
Nombres de gammares liés : le fait que certains gammares se déplacent à 2 traduit un comportement reproducteur qui pourra nous permettre probablement de faire un lien entre concentration d'hormone et comportement reproducteur.
Nombre de mort par cuves : survie des gammares

Nous ne savons pas encore si nous allons indivisualiser nos observations par rapport à chaque gammare dans la cuve ou alors faire une moyenne des données obtenues de chaque cuve, on penche plus pour une moyenne voiture, statistiquement c'est plus simple à traiter, mais il ya quand même des désaventages. On a commencé à faire les mesures. On a prélevé les gammares dans 6 cuves aléatoirement pour les mettre dans 6 boites ( XxY ) remplies avec 100 mL d'eau de la rivière posées sur des feuilles cadriées (1cm=1carreau). Il y a donc 6 gammares par cuves. On a mis des objets opaques autour des boites pour éviter que les gammares ne soient trop autorisées pendant l'enregistrement par la lumière. On a mis le téléphone à une hauteur de X cm de manière à enregistrer les 6 cuves en même temps.On agit les gammares avec une baguette en bois après qu'on les ait tous mis dans les cuves, on laisse reposer 2 minutes et enfin on enregistre la vidéo pendant 1 minute. On a fait tous les enregistrer aujourd'hui, cela fait donc 3 minutes d'enregistrement en tout pour 24 cuves à observer.

L'effet d'un polluant (Bouillie bordelaise) sur Physarum polycephalum (Blob).

( contacts : Rafael.Huertas@etu.sorbonne-universite.fr ; clement.beouch.1@etu.sorbonne-universite.fr ; Lucie.Mazzola@etu.sorbonne-universite.fr ; mona.grelet@etu.sorbonne-universite .fr )

    Dans le cadre de l'UE LU3SV564 intitulée "Démarche scientifique et application à l'écologie" nous avons comme projet d'étudier le blob, Physarum policephalum, et notamment de voir la réaction et les effets qu'ont les polluant sur lui. Sur cette page vous allez trouver des guides sur la maintenance de cette espèce, ainsi que l'avancée de notre projet qui a beaucoup évolué durant le semestre.

Guide pour commencer un élevage de blob (c'est très simple) :

Matériels :

un sclérote de blob ( la souche MALU marche très bien)

une pipette avec de l’eau

des boîtes de pétri

de l’agar-agar

une balance

une spatule

des flocons d’avoine BIO

Explications : 

    Pour pouvoir commencer votre élevage de blob, il vous faut dans un premier temps préparer le milieu dans lequel vous allez les maintenir. Pour cela il vous faut préparer des boîtes de pétri avec de l’agar à 2%. Essayez de préparer plusieurs boîtes dès le début pour pouvoir anticiper les futures multiplications, le blob se développe très vite. Pour conserver les boîtes de pétris, placez-les dans un frigo.

    Après avoir coulé les boîtes avec votre agar chauffé, laissez-les refroidir mais attention à ne pas perdre l’humidité des boîtes. Une fois que les boîtes ont refroidi, vous pouvez positionner le sclérote sur l’agar. Pour pouvoir réactiver le blob, il faut humidifier le papier sur lequel il est positionné. Attention, il ne faut pas mettre directement l’eau sur le blob, mais bien sur le papier à côté. De plus, seules quelques gouttes suffisent (2-3 suivants la taille du sclérote), il ne faut pas noyer le blob ou inonder la boîte. Après avoir fait cela, refermez la boite et positionnez la à l’obscurité (le blob n’aime pas trop la lumière).

    Pour le nourrissage, je vous conseille de ne pas en mettre le jour où vous les réveillez mais attendez plutôt le lendemain pour vérifier s'ils se sont bien réveillés. En terme de quantité de flocons d’avoine à mettre, la première semaine vous pouvez mettre quelques flocons dans la boîte à l’aide d’une pince, il ne faut pas en mettre beaucoup dès le début, c’est souvent la nourriture qui amène les problèmes (champignons/bactéries). Quand vous voyez que le blob se déplace de plus en plus, vous pouvez au fil des multiplications augmenter la quantité de nourriture.
Guide pour faire un sclérose (c'est simple aussi) :

Après avoir pris la main sur l’élevage de blob, vous allez sans doutes vouloir essayer de créer des sclérotes (état de dormance du blob).

Matériel :

un blob en bonne santé (sans champignons ou bactérie dans sa boite)

papier-filtre (je conseille le filtre à café = 100% de réussite)

une boîte de pétri neuve

une spatule

Explications : 

    Le but des sclérotes est de faire rentrer son blob en dormance pour pouvoir le conserver plus longtemps ou pourquoi pas en donner pour que d'autres personnes commencent un élevage.

    Pour faire cela, vous allez prélever un bout de blob (assez dense si possible) et le positionner sur le papier-filtre humide. Placez le papier-filtre avec le blob dans une nouvelle boîte propre. Vous devez au moment où le blob quitte l’agar, et se retrouve sur le papier-filtre, enlevez l’agar (pour éviter qu’il n’y retourne). Une fois que le blob est sur le papier, il va petit à petit se dessécher avec le papier pour devenir un sclérote.

    Je vous conseille de faire tout au long de votre élevage des sclérotes. En effet, une invasion de champignons peut vite arriver et donc si vous avez des sclérotes de côté vous pouvez reprendre votre élevage sans problème.

    J’espère que vous avez compris mes deux guides, vous pouvez continuer de regarder notre page, il y a des photos en plus, cela pourrait être plus parlant. Si vous avez des questions sur la maintenance des blobs vous pouvez me contacter je me ferais un plaisir de vous aider :) ( Rafael.Huertas@etu.sorbonne-universite.fr )

--------------------------------------------------------------------------------------------------------------------------
Rapport 14/10/2022 :
Aujourd’hui nous sommes allés au GreenLab pour voir si nous pouvions réveiller des souches de Physarum polycephalum afin de pouvoir s'entraîner sur la maintenance de l’espèce.

-> On peut voir ici un sclérote de blob. Une des caractéristiques de cet organisme est qu’il peut entrer en phase de dormance (qui peut durer des mois voir des années si les conditions pour sa survie ne sont pas réunies)

Après avoir récupéré des boîtes de pétri déjà préparées avec de , nous avons réveillé les souches sous une hotte pour pouvoir garder le milieu le plus stérile possible.
Pour pouvoir réveiller les souches, il suffit juste d’humidifier le papier sur lequel est le sclérote. Ainsi, le blob va se réveiller et aller ensuite se balader dans la boîte de pétri à la recherche de nourriture.

Pour pouvoir surveiller le réveil et pouvoir leur donner à manger, nous avons décidé de ramener les souches chez nous pendant le week-end.

Rapport 17/10/2022 :

Pendant le week-end, les souches se sont bien réveillées mais se déplacent très lentement, voire stagnent sur le papier.  Nous avons déposé les blobs au Greenlab pour voir s' ils reprennent une croissance normale.

Rapport 19/10/2022 : 
Nous sommes venus au laboratoire pour voir comment allaient les blobs. Les deux souches ne se développent plus du tout et prennent une couleur blanchâtre synonyme de mort de l’organisme. Plusieurs facteurs pourraient expliquer cela : les températures, les conditions ne sont pas adéquates pour le développement de l’organisme; le transport des blobs pourrait aussi expliquer cet événement (choc thermique); où simplement le fait que les sclérotes n’étaient pas fiables…
On voit sur cette photo que les souches ne se développent plus et sont de couleur blanche.

 On a donc décidé de réveiller trois autres souches de localités différentes présentes dans le stock de sclérotes du laboratoire, 2 blobs “Malu” du CNRS et une souche “Mikado” japonais qui est connue pour être très rapide.

 Après avoir choisi les souches à réveiller, il faut donc préparer le milieu dans lequel nous allons les maintenir. Pour cela, il nous faut de l’agar agar et de l’eau que nous allons monter à ébullition et ensuite verser dans les boîtes de pétri le mélange lorsqu’il est encore chaud.

                                         Gauche : L'Agar Agar, c'est ce qu'on utilise pour préparer nos boite de petri; Droite : Boite de petri après avoir coulé l'agar

 
Je me suis entraîné à faire la préparation pour quelques boîtes de pétri avec pour ratio 1g d’agar pour 100ml d’eau. J' ai ensuite préparé d’autres boîtes avec le mélange que M.Hubert m'avait préparé au préalable.

Préparation de plusieurs boites de pétri sous la hotte

Une fois que l'agar a refroidi, nous pouvons poser les sclérotes dessus et les humidifier afin de réveiller les blobs.
Voici à quoi ressemble la boite de petri lorsqu'on démarre le réveil d'un blob

Nous les avons ensuite enfermés avec du papier aluminium pour pouvoir les garder dans l'obscurité (car les blobs grandissent plus vite dans l'obscurité), en attente de leur réveil afin de les nourrir par la suite. Pour information, pour les nourrir, nous utilisons des flocons d'avoine BIO (les blobs raffolent de l'avoine).

Reportage le 20/10/2022 : 
Changement de problématique (à expliquer)  Nous avons aussi décidé de contacter Madame Dussutour pour lui poser quelques questions afin de savoir par exemple quel répulsif elle utilisait lors de ses expériences sur Physarum polycephalum.

Reportage 21/10/2022 :
Ce vendredi, nous sommes passés pour nourrir les blobs et voir leur développement. Les deux souches "Malu" du CNRS, se sont réveillées très rapidement et sont déjà en recherche de nourriture, j'en ai donc mis dans leur boîte. Quant à la souche japonaise "Mikado", aucun signe de réveil sur la boite, j'ai tout de même mis quelques flocons d'avoine pour peut-être "stimuler" son déplacement/réveil.

Rapport 22-23/10/2022 :

Ce week-end, j'ai fait des tests avec des ponts sur une souche AVA que je possède chez moi depuis quelques semaines pour m'entraîner à la maintenance de l'espèce.

J'ai pris deux échantillons de ma souche mère, une passera sur un pont de 2 cm et une autre sur un pont de 4 cm.
J'ai commencé par créer les ponts à base d'agar (les ponts étant très petits, l'agar était plutôt fragile et se cassait facilement). Pour pouvoir être précis dans la découpe j'ai fait des structures en papier afin de respecter les distances.

On peut voir sur la photo les deux challengers que j'ai choisis pour faire le test ainsi que les feuilles me permettant de faire les ponts. Après avoir tout préparé, je dispose les deux blobs, les ponts et l'avoine (qui symbolisent l'arrivée) sur une boîte de petri sèche afin d'éviter l'évasion des blobs lors du test.

J'ai préparé mon appareil photo sur un trépied et j'ai décidé de prendre des photos toutes les 30 minutes pour voir l'avancée des blobs… départ annoncé à 11h pile (samedi).

On peut voir sur la vidéo des images de 11h à 23h du samedi (toutes les 30 minutes environ) et la toute dernière image est à 8h30 le dimanche.
Plusieurs problèmes/imperfections sont à relever. Tout d'abord, on peut voir dans la vidéo que le blob perd beaucoup trop de temps à descendre de sa plateforme d'origine, les quantités d'agar agar n'étant pas les mêmes (il faudra faire attention à cela lors des vraies expériences que nous prévoyons de faire). Il y a ensuite les facteurs lumière et température qui entrent en jeu, en 12h de déplacement (le samedi), il y avait un peu de lumière dans la pièce et surtout une température de 19 à 20 °C, alors que de 23h à 8h30, la pièce était plongée dans le noir à une température allant de 17°C à 18°C. On voit que le blob s'est déplacé beaucoup plus rapidement la nuit que le jour, il faudra garder les mêmes conditions dans nos futurs tests. ( Il faut savoir que cette souche AVA est censée être au top de sa forme à 24°C)

Nous voulions partir sur des ponts de 4 cm de longueur et 1 cm de largeur mais avec mes tests, je pense qu'il serait plus judicieux de faire des ponts de 2 cm de longueur et 1 cm de largeur. Ce sera plus simple à faire et plus rapide à traverser pour le blob. D'autre part, je pense que le blob du pont à 4 cm était moins développé de base que celui du pont à 2 cm. Il faut donc aussi s'assurer que les blobs sont tous développés au même niveau.
Image du test avec le pont de 2 cm de longueur

Image du test avec le pont de 4 cm de longueur

Image montrant le problème des différentes hauteurs des plateformes d'agar
On ne peut pas vraiment se baser sur mes tests car j'ai commis beaucoup trop d'erreurs. Mais pour le déplacement de 23h à 8h30 :

                  Image du test à 23h le samedi                                                             Image du test à 8h30 le dimanche
On voit que sur une durée de 9h30, le blob a presque traversé l'entièreté du pont de 2 cm. De plus on peut voir en dessous de la boite que le blob était arrivé depuis un bon moment (je pense que le blob a mis moins de 8h pour faire toute la traversée). Le temps que mettrait le blob nous inquiétait pour le bon déroulement de nos tests, mais si on réalisait de bonnes conditions, le blob peut faire en quelques heures le déplacement.

On voit sur cette image que le blob est déjà sur la plateforme depuis un certain temps...
Choses à retenir pour les prochains tests :

maintenir les mêmes conditions tout au long du test
faire attention à la quantité d'agar entre les différentes plateformes
avoir des blobs développés au même niveau.

Rapport mois de Novembre : 
Pendant le mois de novembre, nous avons bien avancé sur nos recherches. Dans un premier temps, nous avons accéléré notre manière de multiplier nos souches de blobs. En effet, nous avons suivi la technique mise en place par Mme Dussutour, il s’agit de doubler presque tous les deux jours la colonie en coupant la moitié de la boîte. Mais avec cette technique vient l'arrivée de plusieurs problèmes comme l’invasion de champignons, bactéries impactant nos blobs…
Voici un florilège de photos des meilleures contaminations que nous avons eu :

Mais malgré tout cela nous avons tout de même réussi à multiplier notre souche :

Préparation de toutes nos boites de pétri avant de multiplier nos blobs

On peut voir ici la méthode mise en place pour multiplier au plus vite nos blobs. Chaque souche est coupée en deux pour être remise dans une autre boite.

Nous nous sommes ensuite intéressés au polluant auquel le blob pourrait être confronté dans son milieu naturel. En effet, en s’inspirant de l’étude de Mme Dussutour, nous nous sommes demandé si le blob pouvait, comme avec le sel, acquérir une résistance à un polluant qu’il pourrait rencontrer et l'empêcher d’accéder à sa nourriture dans la nature.

Nous avons donc cherché différents polluants qu'il pourrait être intéressant de tester sur nos blobs pour voir comment ils réagissent.

Nous avons donc pensé à la bouillie bordelaise, au cuivre, au plastique ou encore au sel de déneigement. Ensuite nous avons lancé des tests sur ces polluants.  ( nous avons pensé à d’autres polluants comme la nicotine, le fer ou encore tout type de carburant mais nous avons fait avec ce qu’on avait a disposition dans le laboratoire et ce qui était le plus simple à utiliser.)
Nous avons donc fait plusieurs préparations d'agar avec les différents polluants. Nous les avons coulées dans des boites carrés pour pouvoir ensuite faire des ponts.

Nous avons ensuite préparé les différents tests : 

On peut voir que pour la BB (bouillie bordelaise), le blob a essayé de traverser mais n'est pas allé jusqu'au bout. Pour le test avec le plastique, on voit que le blob passe facilement, en effet il ne fait qu'éviter le plastique et se déplace normalement sur l'agar donc ce test n'est pas très intéressant. Pour le cuivre et le sel, on voit que le blob n'essaye même pas de toucher le pont, il fuit directement vers l'opposé.

Nous avons ensuite fait un deuxième test pour déterminer quel polluant serait le plus intéressant à observer, nous avons donc retenu la BB.

Pendant la recherche du polluant, nous avons aussi cherché un moyen de pouvoir enregistrer en direct le déplacement du blob. De pouvoir faire des photos toutes les 30 minutes pour pouvoir après faire des timelapses et voir le déplacement des blobs sur les ponts. Nous avons appris l'existence d’un outil que possède le Fablab pouvant nous être utile pour faire cela: la Rasberry. Nous avons aussi cherché une boîte pouvant garder l’humidité pour les tests et en même temps pouvant faire office de support pour la caméra.

Voici notre première installation pour faire nos tests :
 
Pour faire nos premiers tests, nous avons été obligés de faire 4 tests dans une même boîte pour pouvoir voir tous nos tests sur la caméra. Nous devons faire ces tests sur 15 blobs différents quotidiennement sur 5 jours pour observer un apprentissage et une possible amélioration à la recherche de nourriture. 

Fin novembre, nous avons eu nos premiers résultats sur nos tests, on peut les voir sur l'image de droite.                                  Ces tests nous ont permis de voir plusieurs problèmes... Dans un premier temps, la proximité entre les tests est un problème car les participants préfèrent fusionner entre eux plutôt que de traverser le pont. Ensuite, il y a le problème de la lumière, on sait que le blob n'aime pas la lumière mais pour avoir des bonnes photos nous avons dû mettre des lampes pendant toute la durée du test. Les blobs seraient donc stressés par la lumière ce qui les empêcherait de traverser le pont.

On peut voir sur cette photo que les blobs vont directement se fusionner entre eux. On peut tout de même voir que certains blobs essayent ou ont essayé de passer sur les ponts. De plus on a observé que nous nous étions trompé sur les concentrations de BB dans les ponts. Ainsi, nous devons donc faire des nouveaux tests en corrigeant toutes nos erreurs.

Voici le timelapse de nos tests : Timelapse Tests BB (avec une erreur concentration)

Choses à retenir pour les prochains tests :

Chercher un moyen de faire des tests séparément pour obliger les blobs à aller sur le pont
Garder de l'obscurité lors des tests pour limiter les stress qu'ont les blobs.

Rapport début décembre :

Après avoir observé nos premiers résultats, nous avons dû trouver un autre moyen de faire notre expérience tout en conservant un taux de stress minimal pour le blob. Nous avons donc cherché une autre “boîte” pour faire nos tests ainsi qu’un moyen de pouvoir contrôler la luminosité à l’intérieur. Notre première idée était d’utiliser des minuteurs sur nos lampes, mais après en avoir parlé à Steve, nous avons trouvé une machine nous permettant de remplir toutes nos demandes : le Phytotron.

Voici notre nouvelle installation, nous avons donc changé notre boîte en plastique pour un Phytotron. Cette machine nous permet de contrôler la température ainsi que la luminosité dans la boîte. Ainsi nous pouvons allumer les lumières exclusivement lors de la prise de photo et le reste du temps le blob est dans l’obscurité, qu’il préfère pour se développer.  

On voit sur cette photo comment nous avons fait l’installation à l’intérieur. Nous n'avons conservé que deux étages de grilles, une positionné en hauteur pour pouvoir mettre notre caméra, et une plus basse pour pouvoir poser nos tests.

Dans un premier temps, nous avons fait nos témoins, donc nos blobs sur un pont d'agar sans polluants avec cette installation. Voici le timelapse des témoins : Timelapse Témoin

Nous avons ensuite fait des tests avec 21 mg de BB. En effet, avec nos précédents tests avec 1g de BB, nous n'avons pas eu de résultats concluants. (Voir timelapse = Timelapse tests Bouillie Bordelaise 1g) Peut être cela était lié à la concentration de BB qui serait trop élevée, nous avons donc baissé la concentration.

Voici le timelapse de nos test avec 21mg de BB dans les ponts : Timelapse Tests 21mg de Bouillie Bordelaise
Outre nos multiples tests, notre colonie de blob se multiplie très bien depuis qu'on applique la technique de Mme Dussutour. Nous n'avons jamais eu autant de blobs que depuis ces derniers jours.

L'effet des sons sur la croissance d'arabidopsis thaliana .

I - Introduction

Certaines personnes pensent que, tout comme nous humains, les plantes sont capables de ressentir la musique. Pour être plus précis, elles seraient capables de ressentir les ondes et induire une réponse physiologique. C’est l’idée qu’à étudié Joël Sternheimer, un physicien et musicien français en 1987. Avec l’aide de biologistes et de musiciens, il constate qu’à chacun des 20 acides aminés qui composent les protéines, on peut y associer une note de musique. Il initie une nouvelle science, la génodique, qui étudie les effets de certaines mélodies sur les organismes vivants, et introduit le terme de « protéodies ». Une protéodie, combinaison des mots “protéine et mélodie”, correspond à une suite de notes assemblées dans un certain ordre pour correspondre à une protéine. Nous avons donc cherché à savoir si cette théorie est applicable et s’il est effectivement possible de stimuler ou inhiber la croissance d’une plante grâce à la musique.

2 - Protocole et plan d’expérience

Pour notre expérience, nous allons utiliser des plantes Arabidopsis thaliana qui sont un organisme modèle en biologie végétale de par leur petite taille, leur cycle de reproduction relativement court. Nous allons réaliser trois expériences pour tester la capacité des plantes à répondre à la musique. Chaque condition sera composée d’une boîte contenant 9 pots. Les boîtes sont équipées d’un dispositif lumineux qui sera allumé 10h par jour, ainsi que de haut-parleur pour diffuser la musique. La musique sera émise pendant 10 minutes la nuit grâce à un Raspberry Pi qui sera programmé pour la lancer à une heure précise.
1- Un contrôle avec des plantes qui ne sont exposées à aucune mélodie
2- Une expérience avec des plantes exposées à une mélodie qui stimule la production d’auxine

3- Une expérience avec des plantes exposées à une mélodie qui inhibe la production d’auxine

Pour chaque condition, nous avons fait les tests en double. Nous avions donc 6 boites au total.

3 - Journal de bord
06/10/22
Nous avons élaboré le plan et commencé à discuter des conditions que nous allions appliquer. Nous avons pensé à diffuser des bruits urbains en comparaison à d’autres naturels, mais avons changé d’idée par faute de temps et de complexité, en effet, nous nous retrouvions avec trop de conditions test.
13/10/22

 Nous avons pris rdv avec Michel Duhamel, le président d’une entreprise « Genodics » qui travaille en collaboration avec Joël Sternheimer, et qui cherche à apporter des solutions innovantes aux agriculteurs et éleveurs pour favoriser la croissance de leurs productions et lutter contre les maladies en renforçant le métabolisme des plantes et des animaux et en leur permettant de s’adapter aux variations climatiques.

Lors de notre entretien, Mr Duhamel nous a donné des conseils et mis en grade sur certains points, notamment le fait qu’il faille bien isoler nos conditions les unes des autres pour que les plantes ne perçoivent que la mélodie souhaitée, de plus nous ne connaissons pas les effets sur l’organisme humain donc il est préférable de ne pas trop s’exposer aux mélodies, et si l’on ressent une sensation désagréable en l’écoutant de la stopper immédiatement. Il nous à précisé que son équipe à mené des recherches sur A.thaliana en utilisant les mêmes mélodies.
Pour des raisons de droit d’auteur, il nous est impossible de communiquer les fichiers  audio des mélodies.
24/10/22

Nous avons planté nos graines d’A.thaliana dans nos différents pots et les avons mises à germer dans une cellule de culture à 25°C. Deux membres de l’équipe étaient chargés d’arroser les graines tous les 3 jours jusqu'à la germination.
27/10/22
Nous avons commencé à programmer des raspberry pi pour diffuser le son. Nous avions besoin d’un programme qui lance la musique à une certaine heure pendant une durée précise avant de l’arrêter. Nous avons donc crée ce programme et avons testé s’il fonctionnait avec le type de haut parleur qui étaient à notre disposition.

CODE

import datetime as dt
from time import sleep
from pygame import mixer

start_time = dt.datetime(year=2022, month=11, day=3, hour=10, minute=18, second=0)
duration = dt.time(hour=0, minute=0, second=40)
periodically = dt.time(hour=0, minute=1, second=0)

today = dt.datetime.today()

if today >= start_time:

print("Date déjà passé")

exit()

# Calcul du temps à attendre
inter = start_time - today
print("Secondes : ", inter.total_seconds())

duration = duration.hour * 3600 + duration.minute * 60 + duration.second
periodically = periodically.hour * 3600 + periodically.minute * 60 + periodically.second

print("duration : ", duration)
print("Period : ", periodically)

mixer.init()
mixer.music.load('sample.mp3')

# Attente
sleep(inter.total_seconds())

while True:

print("Play")

mixer.music.play(-1)

sleep(duration)

mixer.music.stop()

print("End")

sleep(periodically)

17/11/22

Nous avons monté nos boîtes. Nous avons installé des lumières LED de 12V et fixé un haut parleur à chaque boîte.
Nous avons rencontré un problème, puisque 1 plante sur 9 seulement a germé.

24/11/22
Étant donné que seulement une partie de nos graines avaient germé et que cela n’était pas suffisant pour l’exploitation des résultats, nous avons décidé de changer d’organisme et avons donc opté pour des pois.

Nous avons planté nos pois dans des boîtes avec du terreau en conservant le même nombre de réplicats avec une moyenne de deux graines par pot.
01/12/22
Une fois les boîtes prêtes et le programme fonctionnel, nous avons lancé notre expérience. Chaque condition était isolée des autres dans une pièce séparée. La lumière était active de 7h00 à 17h30 pour mimer la lumière naturelle en période hivernale. La musique jouait pendant 10 min à 23h.
L’influence de l’environnement sonore sur le chant des grillons


Stievenard Nicola, Venuanzola Luca, Clouard Andrea et Nina SACCO
UE 564- Démarche écologique et scientifique

Objectif de l'UE :

Introduction au thème:

            L’environnement est un facteur déterminant de la vie et des organismes et donc les variations de celui-ci peuvent avoir un impact sur leur mode de vie. En effet, avec l’urbanisation des milieux ruraux on a un bouleversement des écosystèmes avec l'arrivée de nombreuses pollutions tel que la pollution de l’air, visuelle ou sonore. Nous nous sommes intéressés à l'effet d'éventuelles pollutions sonore sur le chant du grillon.

Pour faire une expérience simple, nous avons choisi de tester l'effet des variation d'intensité sonore d'un son fixe, de 5khz (Son qu'émettent et perçoivent les grillons).

On sait que le chant du grillon est un caractère dysmorphique spécifique aux mâles adultes. Le signal émis est court et répété dans le temps avec une fréquence et une périodicité propre à l’espèce, il est perçu par une oreille tympanique sur le tibia des congénères. Le grillon chante autour des 5 khz.

L’intensité du bruit environnant se mesurant en moyenne autour des 60 dB pour les villes contre 30 dB pour un milieu rural, on pourrait s’attendre à ce que les pollutions sonores urbaines modifient la perception du chant et génèrent une modification, entre autres, de ce comportement de signalisation en groupe.
Une étude sur l’effet des camions routiers sur les grillons de différentes espèces met en évidence la corrélation entre le passage de camion près d’une zone et l’interruption du chant des grillons habitant cette même zone. Ils ont aussi montré que certaines espèces chantaient à des fréquences maximales plus élevées que les grillons des zones plus éloignées, avec des intensités de chants différents. Ils présentent donc des adaptations pour mieux être perçus par le groupe. D'autres études sont intéressantes et ont permis de montrer d'autres adaptation.

Journal de bord :
Initialement nous avions fixé un protocole simple: Dans une boîte à vis, chaque compartiment numéroté correspondrait à un groupe ( 1 mâle + 2 femelles pour encourager un éventuel comportement reproducteur) et serait tapissé de mousse isolante. On pourrait administrer des ordres de passages aléatoires à chaque grillons, et en imaginant que les compartiment à vis assuraient une bonne maniabilité des grillons.
On laisserait nos grillons une semaine sous lampe chauffante, puis sur quelques séances ferions nos mesures.

mais nous avons du faire preuve de flexibilité, comme en témoignera notre journal de bord.
17/11/2022:

           Durant cette séance nous avons reçu les grillons et le matériel nécessaire pour l'expérience . On a donc procédé a la mise en boite des grillons par groupe de 3 avec deux femelles et un mâle dans une boîte que l'on range dans un organisateur (type rangement de vis). Mise en boîte pas facile, on faisait tomber un grillons dans la boîte de manipulation (une des boites du rangement, la n°30) : si c'est un mâle (pas d'ovipositeur) on le pèse (pour identifier des variations de chant inter individuelles? ) et on le dépose dans une boîte avec un numéro, qui sera son numéro si c'est une femelle on la dépose avec un mâle.A la fin de ce rangement on a 30 boîtes de trois grillons. Problème 1: Pas de mousse isolante --> on fait sans, en espérant que les enregistrements des grillons ne se chevauchent pas (ça n'a pas été le cas ) On a mis du parafilm et du scotch à l'avant et à l'arrière des boites pour éviter que les grillons s'enfuient, de plus on a laisser l'organisateur a température ambiante dans un coin du Fablab.

Problème 2: pas de douilles pour fixer les lampes chauffantes, on décide de voir le lendemain.

18/11/2022:

         Quelques grillons sont morts ou en fuite dans les boites des autres: on recommence: sauf pour les groupes ou le mâle, vivant, est resté dans sa boîte.

On a donc changé de stratégies d'aménagement des boites de grillons. les grillons ont donc été disposé dans ces même boites mais en dehors de l'organisateur avec une pochette plastique scotchée a la boîte et percée petits trous afin de les laisser respirer. Rajout de gelée (nutrition + hydratation) qu'on avait oublié la veille.Toute les boites ont été stocké dans un incubateur, avec activation de l'aération et à température contrôlée de 24°C.

24/11/2022:

           On a eu une grosse mortalité des grillons, seulement quelques survivants ont été compté.De grosse trace d'humidité dans les boîtes a été observé, de plus nous avons compté plus de grillons femelle survivante que de grillons mâle, de plus sur les grillons mort des tapis de moisissure était présent. On suppose que les causes de la mort des grillons est dû a une humidité trop importante amenant a une asphyxie des grillons ou également dû au manque de nutriment. On a donc procédé au nettoyage des boites, pour supprimer d'éventuelles odeurs de mort (qui étaient bien perceptible pour nous aussi). On s'est rendu compte que les femelles avaient plus survécu, et il semble qu'elles aient eu recours au cannibalisme. Et quelques recherches sur le grillon plus tard, il semblerait que ce soit une espèce ayant facilement recours au cannibalisme en conditions  de promiscuité et de famine.

On a décidé de mettre nos expériences en pause, nous attendrons de pouvoir enchaîner 2  jours consécutifs de mesures.

12/12/2022:

         

On a donc repris l'expérience en changeant certaines choses. On a donc repris les même boîtes en mettant toujours un mâle et deux femelles, le mâle est pesée à l'aide d'une balance de précision avant de les mettre dans une boîte numéroté. On a mis une pochette plastique au dessus des boîtes comme avant mais cette fois-ci on a fait des trous un peu plus gros pour faciliter le passage de l'air, on a également mis un morceau de carotte avec une gelée pour favoriser leurs survie (qui limite les perte d'eau donc les problèmes d'humidité). Après la mise en boîte de chaque grillon on a établie 6 groupes de 5 boîtes ( étant donnée qu'on avait 30 boîtes) à l'aide du logiciel tirokdo qui nous a permis  un tirage aléatoire des boîtes pour former les groupes. Maintenant que les groupes sont formée on a noté qu'elles boîtes était dans qu'elles groupes et on les a tous mis dans l'incubateur bien aéré et à température contrôlée de 22°C.

Problème: nous avions mal compris les notions acoustiques de dB, nous voulions soumettre nos grillons à des valeurs connus exprimées en dB SPL (Valeurs de pression acoustique, dans lesquelles sont exprimées  les pollutions sonore humaine ex: 90dB seuil de dangerosité, ect). Nous pensions pouvoir imposer cette valeur choisie (40 dB son rural, 70 dB son de villes/métro et son ambiant), mais cela n'était pas possible donc nous avons imposé contrôle= rien, niveau 1 = le son à 50 % du volume de l'enceinte, niveau 2= le son à 100% du volume de l'enceinte. Les six groupes ont un ordre de passage différent: , controle, niveau 1, niveau 2 ou controle, niveau 2, niveau 1.... ( Pour s'assurer que l'ordre de passage n'ait pas d'influence.

Protocole pour l’enregistrement des chants de grillons:  dans une pièce calme et on a procédé groupe par groupe en laissant trois minutes de calme puis deux minutes d’exposition au son si on expose un son, et ensuite 2 minutes d’enregistrement à l’aide de 5 micros d’enregistrement ( une sur chaque boîte). Le bruit était trop fort, il était préférable de sortir de la pièce et d'activer l'enceinte Bluetooth à distance.

Remarque:
Les grillons sembles apprécier le morceau de carotte ajouté.

13/12/2022:

         

Pas de trace d'humidité sur les boîtes, peu de mortalité ( un seul mâle mort) et peu de fuite ( une seule femelle s'est enfuie): bonne stratégie de mise en boîte. On a échangé le mâle mort avec un nouveau mâle pesé. On est passé a l'enregistrement des chants des grillons, pour cela on a utilisé des micro d'enregistrement et on a cherché une pièce calme ou l'on avait très peu de bruit on a choisit la réserve du fablab. Pour faciliter le chant des grillons on a ajouté un ventilateur chauffage car la pièce avait une température trop basse et les grillons chantait très peu dans le froid. On a procédé groupe par groupe en commençant par le groupe A. On a pu noter que certain groupe chantait très bien (ceux du matin et ceux de fin d'aprèm) et d'autre un peu moins bien (milieu d'aprem).
remarque:
On suppose que les facteurs qui on influencé certain groupes a ne pas chanté en milieu d'après midi était le bruit ambiant qui était plus dérangeant l'après midi dû au nombre de personne au fablab qui était plus important l'après midi.

15/12/2022:

            Maintenant que la partie pratique à été réalisé, on passe a la partie théorie. Pour cela on a utilisé le logiciel Audacity pour analyser les enregistrement obtenus. On a réussi a identifier les chants ce qui nous a permis de les isoler afin de pouvoir les étudier grillons 6.png. Pour étudier les son on a réglé audacity  en décibel et en demi-onde et ont a reporté les intensité obtenus sur un tableau, on à également noté les type de chant. Après avoir obtenus toute les données, on a utilisé le logiciel R afin d'établir des graphiques statistiques afin de pouvoir répondre a notre problématique.
Méthodes et matériels:

      Pour cette expérience nous avons utilisé 90 grillons Gryllus bimaculatus dont 30 mâles et 60 femelles. Pour les isoler on a utilisé des boîtes de rangement en plastique numéroté où l'on a mis des pochettes plastiques tenues par des élastiques, ces pochettes ont été percées au préalable pour éviter l'asphyxie des grillons. Après la préparation des boîtes, on a séparé les grillons en faisant en sorte d'avoir 1 mâle et 2 femelles par boîtes  grillon 1.png. Avant de mettre les mâles ont les a pesée avec une balance.
Pour favoriser leur survie dans ces boîtes nous avons mis pour chaque boîte une gelée et une tranche de carotte avant de d'introduire chaque mâle dans une boîte grillons 2.png.
Après avoir introduit les grillons dans chaque boîte nous avons établie six groupes ayant des ordre de passage différent selon l'exposition au son. Pour établir ces groupes on a utilisé le logiciel tirokdo qui nous a permis un tirage aléatoire des boîtes pour former les groupes grillons 3.png. On a donc 5 boîtes par groupe.
Pour l'enregistrement des chants de grillons on s'est installé dans une pièce calme et on a procédé groupe par groupe en laissant trois minutes de calme puis deux minutes d'exposition au son si on expose un son et ensuite 2 minutes d'enregistrement à l'aide de 5 micro d'enregistrement grillons 4.jpeg. Pour l'exposition au son on a utilisé une enceinte UE BOOM 3.
RAPPORT FINAL: 

L’influence de l’intensité du son ambiant sur l’intensité du chant des grillons n’a pas pu être démontrée.

auteurs: Nicola Stievenard, Venanzuola Lucas, Clouard Andréa, Sacco Nina

Introduction

L’environnement d’un milieu est un facteur déterminant des comportements des organismes qui le composent. L’urbanisation d’un milieu peut bouleverser l’équilibre d’un écosystème qui demandera alors à certains organismes un effort d’acclimatation.

 Le chant du grillon, Gryllus bimaculatus est un trait d’histoire de vie assurant le succès reproducteur des mâles. Le son émis par stridulation, (frottement des ailes antérieures), est d’une fréquence d’environ 5kHz1, il est perçu par une oreille tympanique sur le tibia des congénères situé sur ses pattes avant2.  A savoir que l’intensité sonore à laquelle les grillons réagissent est de 80dB SPL3. Le chant du grillon est un caractère dysmorphique spécifique aux mâles adultes. Le signal émis est court et répété dans le temps avec une fréquence et une périodicité propre à l’espèce.

 Certaines études de corrélation ont mis en évidence un lien entre pollution sonore, élévation de l’intensité sonore, et modification du comportement de chant dans des milieux ruraux comme : l’interruption du chant de grillons 2, la modification des fréquences, des intensités de chant 4 ou encore la désynchronisation entre les congénères 5, très bien illustrés dans le cadre d’études sur le passage de camions à proximité des habitats des grillons étudiés.

Par exposition de mâles à un son continu de 5kHz à différentes conditions d’intensité, nous avons mesuré l’intensité du chant enregistré, avec pour objectif de  montrer une éventuelle différence de l’intensité sonore sur l’intensité du chant émis par le grillon 4.

L’intensité sonore d’un son de 5khz influe-t-elle donc sur l’intensité maximale du chant des grillons ?

L'intérêt de cette question est d’évaluer la capacité de plasticité des grillons à un phénomène relevant de l'anthropisation des territoires.

Nos hypothèses étaient les suivantes:

L’intensité maximale du chant reste inchangée en modifiant l’intensité de l’environnement sonore

L’intensité maximale du chant varie avec l’augmentation du volume sonore.

On suppose que l’environnement sonore aura une influence sur le chant des grillons. On s’attend donc à avoir une différence significative du chant des grillons selon l’intensité sonore.

Matériel et méthodes :

Matériel et méthodes

Captivité des grillons: Boîtes à vis recouvertes de feuilles plastiques percée par nos soins et fermées par élastiques, incubateur à 23°C et gelée de nutrition + carottes.

1 mâle + 2 femelles/ boîte pour encourager comportement reproducteur. (FIG.S2)

Enregistrement  et exposition: Clé USB “espion” dictaphone (x5), Enceinte: Ultimate ears boom 3 , Son utilisé: 5000hz test tone 10hr sur youtube, Chauffage : petit chauffage d’appoint

Logiciels: exploitation des résultats : Audacity , analyse des résultats : R Studio, attribution des groupe de passage: Tirodoko

Nos expériences se sont portées sur Gryllus bimaculatus réputé pour se reproduire a partir de 20°C (Toptimale=30°C), et facile à se procurer.
Nous avons fait le choix d’utiliser un total de 90 grillons d'élevage pour former des groupes de 2 femelles avec un mâle. Chaque groupe à été exposé à toutes les conditions: Bruit ambiant, 50% de la puissance de l’enceinte, 100% de la puissance de l’enceinte.

Pour minimiser les biais, nous avons réparti nos grillons et leur avons attribué des ordres de passage par condition de manière randomisée.
Pour l’enregistrement, nous avons emmené, par groupe de passage (5 boîtes/groupes) les grillons dans une pièce, la plus silencieuse possible, laissant sur des chaises les grillons, les séparant toujours de la même distance et à la même distance de l’enceinte. On déposait les clé USB, prête à l’enregistrement sur chacune des boîtes, puis quittons la pièce.

Pendant l’enregistrement: 2 min d’acclimatation à l’environnement, 3 minutes d’exposition à la condition, et 2 minutes post-exposition (que l’on va exploiter).

Sur audacity: visualisation des données en forme de demie onde, avec choix d’une échelle en DB, on relève l’intensité maximale d’exposition et celle de chant. (FIG.S1)

Analyses des données

Notre variable explicative est l’intensité sonore d’exposition, il s’agit d’une variable ordinale fixée sur 3 niveaux : contrôle, 1 et 2.

Notre variable dépendante est l’intensité du chant des grillons, une variable quantitative continue.

Nos mesures consistaient en une répétition de mesures sur des mêmes sujets pour comparer les moyennes des 3 groupes (contrôles, niveau 1 et niveau 2).

Les données ne suivant pas toutes une loi normale, il fallait exclure l’anova paramétrique à un facteur et nous avons effectué le test non paramétrique Kruskal Wallis.
Résultats: 
Nous avons d’abord procédé à un contrôle, pour s’assurer que les conditions étaient bien différentes en termes d'intensité, car mal fixées (cf discussion), et cela semble être le cas  sur le graphe. (FIG1). Les résultats statistiques indique une valeur de niveau différente du contrôle, mais mises deux à deux les résultats semblent indiquer un égalité ce qui paraît incohérent.

Nous noterons que seuls 60 enregistrements présentaient un bruit exploitable émis par les grillons,répartis en proportions variables , à l’oreille en différents  types de chants (FIG3.A ,B, C): le chant “vrai”, le cliquetis, mixte et autre.

Nous n’avons pas pu mettre en évidence une différence significative entre différentes intensités de chants enregistrés, nous remarquons également qu’elles appartiennent à de larges gammes de valeurs. ( En annexe, nous avons effectué des test supplémentaires sur d’autres paramètres).
Discussion:

L’objectif de notre expérience était de montrer l’influence de l’intensité sonore sur l’intensité sonore du chant des grillons. Les résultats de nos expériences tendent à prouver qu’il n’y en a pas. Pour autant, d’autres études corrélatives de la littérature scientifique semblaient montrer l’existence d’une telle influence de la  part de l’environnement sonore, comme par exemple l’effet du passage de camions à proximité de grillons sur la fréquence de chant et la 4, ou Pour comprendre nos résultats, deux chemins s’offrent à nous: soit l’intensité n’est pas le paramètre de l’environnement qui génère ce changement de comportement de chant des grillons illustré dans ces études corrélatives, soit notre expérience n’a pas pu le montrer.

Et en effet, notre démarche présente de nombreuses voies d’amélioration.

Dans un premier temps, la fixation des conditions n’était pas bien établie, les paramètres de températures dans la salle variaient (Rajout du chauffage, variation dans la journée, bruits parasites,...) influençant peut être le comportement des grillons et la prise de nos mesures. On avait souligné dans les résultats que nos valeurs statistiques ,comparant les intensités d’exposition entre elles, n’indiquent pas de différence une à une. Cela peut être, soit la conséquence d’un manque de maîtrise de R le résultat de ce biais, soit de ce manque de rigueur.

Les conditions de captivité des grillons n’étaient pas optimales ( Peu d’espace, humidité, température), le sachant nous nous sommes pressés pour faire nos expériences en espérant que nos grillons ne meurent pas. (Nous avions eu des problèmes de cannibalisme et mort de quasiment tous nos grillons sur une semaine lors de notre première tentative).

Cela pose des questions sur la répétabilité de l'expérience, et pose un éventuel biais pour le comportement des grillons.

Si l’on s'intéresse à l’exploitation des résultats, nous avons choisi d’exploiter l’ensemble des chants que nous avons pu enregistrer, premièrement car nous n’avions pas assez de connaissances sur le chant des grillons pour envisager d’exclure les cliquetis et autres, mais également parce nous n’avions pas assez de vrai chants pour faire de vraies statistiques. Dans le cas ou les cliquetis et autres ne sont pas de vrais chants, au sens de la communication (Il pourrait s’agir par exemple d’une réaction de stress, par frottement des ailes par exemple), inclure ces derniers fausserait entièrement nos résultats,d’autant que la proportion de vrai chant est très différentes entre les conditions (FIG.S3).

D’autre part, nous avions mal compris la notion d’intensité sonore et de décibel, nous souhaitions initialement exposer nos grillons à différents dbSPL de pression acoustique, perçus par l’oreille humaine (Ceux dont on parle au quotidien, seuil d’audition, etc), mais ce sont des décibels différents que ceux mesurés dans des enregistrement qui sont des dB FS6. C’est pendant l’analyse des résultats, en voyant des décibels de valeurs négatives que nous avons réalisé, trop tard, notre erreur.

Cette erreur fait perdre son sens à l'intérêt de notre expérience, qu’on a voulu inscrire dans le cadre des pollutions sonores ,souvent exprimées en dBSPL, car on ne sait pas ce que représentent ces mesures concrètement. CF bibliographie annexe.

Il nous faudrait donc revoir notre protocole : faire des enregistrements sur un plus grand nombre de grillons, privilégier des lampes chauffantes à l’incubateur, trouver une pièce isolée, calme adaptée à des enregistrements.

Conclusion:
Pour conclure, nous n'avons pas pu rejeter l’hypothèse selon laquelle l’intensité sonore environnementale est sans influence sur l’intensité du chant des grillons.

Notre expérience était soumise à de nombreux biais, et sa valeur scientifique est discutable, les résultats que nous avons donc obtenus ne permettent pas de conclure sur l’absence de causalité entre les intensités d’exposition et de chant, mais elle n’est pas suffisante pour démontrer qu’il en existe un. 

Bibliographie:
1 Jonsson, Thorin, Fernando Montealegre-Z, Carl D. Soulsbury, et Daniel Robert. « Tenors Not Sopranos: Bio-Mechanical Constraints on Calling Song Frequencies in the Mediterranean Field-Cricket ». Frontiers in Ecology and Evolution 9 (2021). https://www.frontiersin.org/articles/10.3389/fevo.2021.647786.2 Schöneich S. Neuroethology of acoustic communication in field crickets - from signal generation to song recognition in an insect brain. Prog Neurobiol. 2020 Nov;194:101882. doi: 10.1016/j.pneurobio.2020.101882. Epub 2020 Jul 13. PMID: 32673695.3 Jones, M. D. R., et M. Dambach. « Response to Sound in Crickets without Tympanal Organs (Gryllus Campestris L.) ». Journal of Comparative Physiology 87, no 1 (1973): 89‑98. https://doi.org/10.1007/BF00699298.4 Duarte, Marina H. L., Ernesto P. Caliari, Marina D. A. Scarpelli, Gabriel O. Lobregat, Robert J. Young, et Renata S. Sousa-Lima. « Effects of mining truck traffic on cricket calling activity ». The Journal of the Acoustical Society of America 146, no 1 (juillet 2019): 656‑64. https://doi.org/10.1121/1.5119125.5 M. Hartbauer, M. E. Siegert, I. Fertschai, et H. Ro¨mer. « Acoustic signal perception in a noisy habitat: lessons from synchronising insects », s. d. https://link-springer-com.accesdistant.sorbonne-universite.fr/content/pdf/10.1007/s00359-012-0718-1.pdf.6 Eschalier N., Les différents types de décibels (dB), consulté le 21/12/2022: https://deveniringeson.com/decibels-db/

Liens annexes pour comprendre audacity / Les décibels:

Des decibels négatifs sous audacity ?, Forum Audiofanzine, consulté le 21/12/2022: https://fr.audiofanzine.com/forums-thematiques/forums/t.531686,des-decibels-negatifs-sous-audacity.html
Spectrogram View, Audacity Manual, consulté le 20/12/2022: https://manual.audacityteam.org/man/spectrogram_view.html#meaning

📹 UE LU1SXARE - CURIOUS

Atelier de Recherche Encadré CURIOUS-Info

Contexte et objectifs de l'Atelier

Des recherches sont nécessaires pour répondre aux nombreuses questions posées sur les réponses des écosystèmes et espèces des fonds marins au changement climatique et aux impacts d’activités humaines.  Ces recherches font appel au développement de nouveaux outils d’observation in situ miniaturisés, autonomes et à coûts limités pour pouvoir être largement partagés. Des caméras et des capteurs intégrés à des caissons étanches permettent notamment d’étudier les fluctuations microclimatiques et de décrire comment les espèces font face aux évènements les plus extrêmes. Des dispositifs déployés lors d'expéditions récentes en grande profondeur sont transférés pour les milieux littoraux dans le cadre du projet de recherche participative MOOREV (CNRS-MITI et Fondation de France).
L'atelier de Recherche Encadré CURIOUS se déroule  sous forme projets dédiés à l’analyse d’images sous-marines acquises sur le littoral, ou au développement des méthodes d'acquisition pour les rendre plus accessibles. Les groupes de projet peuvent choisir d'explorer au FabLab les possibilités offertes par les technologies actuelles open source, notamment le pilotage de caméras reconditionnées par une interface de type Arduino nano ou ESP32 pour une autonomie de plusieurs jours à plusieurs semaines.  Les groupes de projet utiliseront différents logiciels pour calibrer et analyser des vidéos et photos sous-marines, construire une base de donnée de reconnaissance d’espèces, et élaborer des tutos pour permettre à d’autres utilisateurs de contribuer à ces recherches.Projet -ScFo MOOREV_Timer-Camera

Objectif : Définition, évaluation et test d'une interface programmable et de l'alimentation pour l'acquisition de séquences photos et vidéo en autonome avec GoProHero3+ et LED Cree sur de longues durées (plusieurs semaines à mois) avec ESP32et/ou Arduino Nano.
Matériel fourni :
2 Arduino Nano 1 GoPro HERO3+Carte interface CamDo TTL004BLINK CamDo Time Lapse Controller1  Carte mesure SENSE0161 DFRobot avec electrode pH3 LED CREEProjet-ScFo MOOREV-Stéréovision_Calibration

Objectif : Etablir un protocole d'acquisition d'image sous-marines en stéréovision. Réalisation du banc de calibration pour deux caméras GoProHero3+  et tests pour application en imagerie sous-marine.
Matériel fourni :
2 GoPro HERO3+ reconditionnées 2022A et 2022B2 caissons 30m pour essai dans l'eau au FabLab1 Caisson GoBenthic GroupBinc avec Extension et Connecteur (pour mesures de taille, distance entre caméras)Echiquier ou mire à fabriquer au FabLabProjet-ScIn MOOREV-Stéréovision-Traitement_image


Objectif : Etablir un protocole d'analyse d'image en stéréovision pour application en imagerie sous-marine
Traitement des images avec correction de distorsion - voir GitHub UnderSea (PFE Master SPI-ISI)
Tests cartes et caméra Raspberry : comparaison de différentes stratégies (Raspberry-Pi avec traitement embarqué versus GoPro Hero3+ et traitement différé).
Matériel fourni :
2 GoPro HERO3+ reconditionnées 2022A et 2022B + exemple de vidéos in situ
Projet-ScIn MOOREV_ Trigger-Caméra Modulation Fréquence

INTRODUCTION
Le but de notre projet ARE est de déclencher une caméra Go Pro à l’aide d’une carte électronique Arduino dans le but de récolter des données. Les données qui seront les causes du déclenchement pourront être le pH de l’eau, la température etc. Cela appelle aussi à une adaptation de la caméra au milieu avec un processus d’éclairage la nuit, un potentiel processus de détection des espèces. Le cœur du sujet résidera donc dans le fait de déclencher la caméra sous l’action de certaines conditions nécessaires. Le dessein final serait de mettre le système dans des conditions réelles en milieu extérieur, ce pendant plusieurs jours, afin d’en observer les résultats.
Objectif : Intégration d'une carte mesures de pH + température et d'une Arduino pour la programmation du déclenchement  d'une caméra Go Pro autonome.
Il s'agit d'interfaçage de l'Arduino avec les cartes de mesures de pH SENSE0161 (ou ADCM355), avec enregistrement des mesures sur carte microSD, pour pouvoir réveiller  la caméra sur un seuil de mesure de température ou de pH.
Matériel fourni :
1 Arduino Nano1 carte support microSD 2  Cartes mesure SENSE0161 DFRobot avec electrodes pH2 cartes mesures  ADUCM355 WATER QUALITY SENSOR (T°C + pH ou REDOX(ORP)2 sondes T°C long. 30 cm - thermistance (Thermocoax)
Code pour déterminer la température
/*
 * Created by ArduinoGetStarted.com
 *
 * This example code is in the public domain
 *
 * Tutorial page: https://arduinogetstarted.com/tutorials/arduino-temperature-sensor
 */

#include <OneWire.h>
#include <DallasTemperature.h>

const int SENSOR_PIN = 13; // Arduino pin connected to DS18B20 sensor's DQ pin

OneWire oneWire(SENSOR_PIN); // setup a oneWire instance
DallasTemperature tempSensor(&oneWire); // pass oneWire to DallasTemperature library

float tempCelsius; // temperature in Celsius
float tempFahrenheit; // temperature in Fahrenheit

void setup()
{
 Serial.begin(9600); // initialize serial
 tempSensor.begin(); // initialize the sensor
}

void loop()
{
 tempSensor.requestTemperatures(); // send the command to get temperatures
 tempCelsius = tempSensor.getTempCByIndex(0); // read temperature in Celsius
 tempFahrenheit = tempCelsius * 9 / 5 + 32; // convert Celsius to Fahrenheit

 Serial.print("Temperature: ");
 Serial.print(tempCelsius); // print the temperature in Celsius
 Serial.print("°C");
 Serial.print(" ~ "); // separator between Celsius and Fahrenheit
 Serial.print(tempFahrenheit); // print the temperature in Fahrenheit
 Serial.println("°F");

 delay(500);
}

Code de déclenchement de caméra
#include <OneWire.h>

// Définir la broche de données pour le capteur DS18B20
#define ONE_WIRE_BUS 2

// Initialiser l'objet OneWire
OneWire oneWire(ONE_WIRE_BUS);

void setup() {
 // Ouvrir une communication série à 9600 bauds
 Serial.begin(9600);
}

void loop() {
 // Initialiser le capteur
 byte addr[8];
 if (!oneWire.search(addr)) {
 // Si aucun capteur n'est détecté, attendre
 delay(1000);
 return;
 }

 // Vérifier que le capteur est bien un DS18B20
 if (addr[0] != 0x28) {
 // Si ce n'est pas un DS18B20, attendre
 delay(1000);
 return;
 }

 // Initialiser la communication avec le capteur
 oneWire.reset();
 oneWire.select(addr);
 oneWire.write(0x44); // Lancer la conversion de température

 // Attendre la fin de la conversion
 delay(1000);

 // Lire la température
 oneWire.reset();
 oneWire.select(addr);
 oneWire.write(0xBE); // Demander la lecture de la température
 byte data[9];
 for (byte i = 0; i < 9; i++) {
 data[i] = oneWire.read();
 }
 int temp_raw = (data[1] << 8) | data[0];
 float temp_celsius = (float) temp_raw / 16.0;

 // Afficher la température
 Serial.print("Température: ");
 Serial.print(temp_celsius);
 Serial.println(" °C");

 // Attendre avant de recommencer
 delay(1000);
}

Code pour avoir le pH
/*
 # This sample code is used to test the pH meter V1.0.
 # Editor : YouYou
 # Ver : 1.0
 # Product: analog pH meter
 # SKU : SEN0161
*/
#define SensorPin A0 //pH meter Analog output to Arduino Analog Input 0
#define Offset 0.00 //deviation compensate
#define LED 13
#define samplingInterval 20
#define printInterval 800
#define ArrayLenth 40 //times of collection
int pHArray[ArrayLenth]; //Store the average value of the sensor feedback
int pHArrayIndex=0;
void setup(void)
{
 pinMode(LED,OUTPUT);
 Serial.begin(9600);
 Serial.println("pH meter experiment!"); //Test the serial monitor
}
void loop(void)
{
 static unsigned long samplingTime = millis();
 static unsigned long printTime = millis();
 static float pHValue,voltage;
 if(millis()-samplingTime > samplingInterval)
 {
 pHArray[pHArrayIndex++]=analogRead(SensorPin);
 if(pHArrayIndex==ArrayLenth)pHArrayIndex=0;
 voltage = avergearray(pHArray, ArrayLenth)*5.0/1024;
 pHValue = 3.5*voltage+Offset;
 samplingTime=millis();
 }
 if(millis() - printTime > printInterval) //Every 800 milliseconds, print a numerical, convert the state of the LED indicator
 {
 Serial.print("Voltage:");
 Serial.print(voltage,2);
 Serial.print(" pH value: ");
 Serial.println(pHValue,2);
 digitalWrite(LED,digitalRead(LED)^1);
 printTime=millis();
 }
}
double avergearray(int* arr, int number){
 int i;
 int max,min;
 double avg;
 long amount=0;
 if(number<=0){
 Serial.println("Error number for the array to avraging!/n");
 return 0;
 }
 if(number<5){ //less than 5, calculated directly statistics
 for(i=0;i<number;i++){
 amount+=arr[i];
 }
 avg = amount/number;
 return avg;
 }else{
 if(arr[0]<arr[1]){
 min = arr[0];max=arr[1];
 }
 else{
 min=arr[1];max=arr[0];
 }
 for(i=2;i<number;i++){
 if(arr[i]<min){
 amount+=min; //arr<min
 min=arr[i];
 }else {
 if(arr[i]>max){
 amount+=max; //arr>max
 max=arr[i];
 }else{
 amount+=arr[i]; //min<=arr<=max
 }
 }//if
 }//for
 avg = (double)amount/(number-2);
 }//if
 return avg;
}
Code de déclenchement avec pH
// Inclure la bibliothèque pour la communication série
#include <SoftwareSerial.h>

// Définir les broches de communication série
SoftwareSerial pHSerial(2, 3); // RX, TX

// Définir la broche de commande de la caméra
const int cameraPin = 4;

// Définir les constantes pour la calibration du capteur de pH
const float pH7Voltage = 2.5;
const float pH4Voltage = 1.98;
const float pH10Voltage = 3.07;

// Fonction pour convertir la tension en pH
float convertToPH(float voltage) {
 float pH = 7 - (voltage - pH7Voltage) / (pH7Voltage - pH4Voltage) * 3;
 return pH;
}

void setup() {
 // Ouvrir la communication série pour le débogage
 Serial.begin(9600);
 // Configurer la communication série pour le capteur de pH
 pHSerial.begin(9600);
 // Définir la broche de commande de la caméra en mode sortie
 pinMode(cameraPin, OUTPUT);
}

void loop() {
 // Lire la tension du capteur de pH
 pHSerial.write('R'); // Envoyer la commande pour lire la tension
 delay(1000); // Attendre la réponse
 while (pHSerial.available() < 4) {} // Attendre la réponse complète
 float voltage = (float)pHSerial.parseFloat() / 1000.0; // Convertir la réponse en voltage
 // Convertir la tension en pH
 float pH = convertToPH(voltage);
 // Afficher les résultats
 Serial.print("Voltage = ");
 Serial.print(voltage, 2);
 Serial.print(" V, pH = ");
 Serial.print(pH, 2);
 Serial.println();
 // Déclencher la caméra si le pH est inférieur à 7
 if (pH < 7) {
 digitalWrite(cameraPin, HIGH);
 delay(500);
 digitalWrite(cameraPin, LOW);
 }
 // Attendre une seconde avant de recommencer
 delay(1000);
}

⚠Les codes ci-dessus restent à tester, aucune manipulation n'a été faites (On n'a pas eu accès à notre boite ouin ouin 🥲🥲).

Mardi 11 Avril

Nous avons eu accès à notre boîte et avons put effectuer quelques manipulations.
Nous avons testé le code pour la mesure du pH que l'on à trouvé sur le wiki de dfrobot; à l'aide d'une sonde de pH, de notre carte Arduino Nano, d'un Mac et de quelques branchements.
:

Comme les images ci-dessus l'indique, le code a fonctionner et la sonde est en capacité de prélever le pH d'un liquide. ( L'eau étant prélevée du robinet il est normal que le pH ne soit pas exactement équivalent à 7, mais qu'il s'en approche)

Nous avons aussi testé le code de prélèvement de température écrit précédemment, le code semble bien fonctionné, on reçoit bien des valeurs de Température dans le Serial Monitor cependant les valeurs ne semblent pas cohérentes probablement  dût à un problème de conversion .

BIBLIOGRAPHIE

Analog Input | Arduino Documentation. https://docs.arduino.cc/built-in-examples/analog/AnalogInput. Consulté le 30 mars 2023.

analogRead() - Arduino Reference. https://www.arduino.cc/reference/en/language/functions/analog-io/analogread/. Consulté le 30 mars 2023.

Nano | Arduino Documentation. https://docs.arduino.cc/hardware/nano. Consulté le 30 mars 2023.

SPI - Arduino Reference. https://www.arduino.cc/reference/en/language/functions/communication/spi/. Consulté le 30 mars 2023.

WiFi101 - Arduino Reference. https://www.arduino.cc/reference/en/libraries/wifi101/. Consulté le 30 mars 2023.

« Arduino - Temperature Sensor | Arduino Tutorial ». Arduino Getting Started, https://arduinogetstarted.com/tutorials/arduino-temperature-sensor. Consulté le 30 mars 2023.

DS18B20 Temperature Sensor For Arduino - DFRobot Wiki. https://wiki.dfrobot.com/Gravity__DS18B20_Temperature_Sensor__Arduino_Compatible__V2_SKU__DFR0024. Consulté le 30 mars 2023.

SKU SEN0161 PH Meter. https://wiki.dfrobot.com/PH_meter_SKU__SEN0161_. Consulté le 7 avril 2023.
Projet-ScIn_MOOREV-Espèces-annotation

Objectif : Réaliser un tutoriel pour la construction d'une banque d'images sous-marines pour la reconnaissance d'espèces communes des habitats littoraux de Atlantique.Comparaison des images extraites des séries acquises par le projet MOOREV avec les bases de données biodiversité. Tests des logiciels d'annotation d'images (Roboflow ou autres logiciels Open Source).Le projet de recherches participatives MOOREV

Le projet MOOREV-Microclimats et nouveau Outils d’Observation des Réponses du Vivant sur les fonds marins est soutenu par la Mission Interdisciplinaire et des Initiatives Transverses du CNRS et également par la Fondation de France.
Le projet s’inspire d'instruments développés pour les recherches sur les fonds marins en grande profondeur pour construire des instruments pouvant être utilisés par un plus large public. Notre objectif est de permettre la co-conception et l’appropriation de modules d'observation miniaturisés et autonomes, dans un cadre de recherches participatives, pour partager les connaissances sur le rôle d'espèces constructrices d'habitats et la sensibilité aux perturbations climatiques. 
L’intégration de caméras et de capteurs et l’adaptation de méthodes d’analyse d’image et des outils de l’IA sont développées avec le FabLab SU dans le cadre des Ateliers de Recherche Encadrés CURIOUS (Licence 1 Sorbonne Université).Le déploiement des équipements sur le terrain, puis l’analyse des données acquises, participent aux supports pédagogiques développés à la Station Marine de Concarneau dans le cadre des ateliers des Aires Marines Educatives animés par Esprit Nat'ure.Documentation MOOREV-Timer-Camera ScFo

Information:
Groupe de projet: L1 - Science Formelles Maths-Info - (février - avril 2023)
- CHU Amélie amelie.chu@etu.sorbonne-universite.fr
- SAE LIM Thierry thierry.sae_lim@etu.sorbonne-universite.fr
- PERRIN DE BRICHAMBAUT Jules jules.perrin_de_brichambaut@etu.sorbonne-universite.fr
Contexte:
Dans le cadre de notre projet d'ARE, nous nous focalisons sur la récolte de données images et vidéos d'espèces marines à l'aide de caméras et de capteurs.

Objectif:
Notre objectif est de concevoir un système autonome qui permet d'enregistrer ces données en profondeur sur une longue durée (plusieurs semaines à plusieurs mois), à faible coût et à faible consommation d'énergie.

Le but de ce tuto est de mettre en place un système autonome sous marin qui permet de prendre des données photos et vidéos d’espèces aquatiques sur une durée déterminée. Notre objectif est donc de finaliser un prototype peu coûteux et ayant une consommation d’énergie minimale.
Matériel:
- GoPro Hero 3+S
- Adafruit ESP32 Feather [0]
- Arduino NANO
- Breadboard
- connecteur arrière de la caméra (connecteur herobus) modèle DD1P030MA1
- Carte SD 64 Go (ou 32 Go)
- ESP32-Cam
- Multimètre (modèle utilisé TENMA 72-14620)
Le tuto se découpera en plusieurs parties:

IDE et programmation des microcontrôleurs
Réalisation de tests de consommations
Script de la GoPro
Assemblage du prototype
Alternative: ESP32-Cam
Références

Machines utilisées:
- fer à souder

1.TUTO:  IDE et programmation des microcontrôleurs
Etape 1 :
On installe tout d’abord l’IDE Arduino (Integrated Development Environment) pour pouvoir programmer les scripts des deux cartes: https://www.arduino.cc/en/software [1] (lien pour le téléchargement).

Interface du logiciel en question
Une fois téléchargé, lancez l’application. En haut à gauche, choisir le microcontrôleur adapté (dans notre cas, il s’agit d’un Adrafruit ESP32 Feather, d’un ESP32-CAM ou d’un Arduino Nano). Sur la gauche, cliquer sur la deuxième icône ‘BOARDS MANAGER’ et rechercher ‘esp32’. Installer la plus récente version de la librairie ‘esp32’ par Expressif Systems. Cela permettra d’avoir la gestion pour programmer les ESP32.
Etape 2:
 Nous allons maintenant écrire les scripts pour les deux cartes. Notre script va simuler une séquence où la carte allume une LED toutes les minutes pendant 5 secondes.
Le lien vers notre GitHub contient les scripts des deux cartes dans les deux fichiers ESP32 et Arduino [2] :
https://github.com/ursusnocte/ARE_Curious_Info-Moorev-Timer-Camera [3]
Pour transmettre les fichiers, relier la carte à l’ordinateur, sélectionner le port COM de la carte, et cliquer en haut à gauche sur le bouton flèche ‘upload’. Pour chaque modification du script, il faudra réitérer cette opération.

2.TUTO: Réalisation de tests de consommations

On réalise maintenant les tests de consommations. Pour cela, nous allons utiliser le multimètre. Nous souhaitons récolter les données.

Etape 1: installation du logiciel
 En fonction du multimètre utilisé, la fonctionnalité peut ne pas être disponible. Il faudra alors noter manuellement les données. Dans le cas contraire, installer le logiciel associé. Dans notre cas avec ce modèle, installer le logiciel à l’aide du CD fourni avec le manuel d’utilisation. Lancer le logiciel puis brancher l’ordinateur au multimètre.
Modèle du multimètre utilisé dans notre cas : TENMA 72-14620
- Installer sur l’ordinateur le modèle du multimètre correspondant au modèle
- Connecter l’ordinateur et l’appareil grâce au câble fourni avec l‘appareil
- Régler le logiciel sur la connexion via USB, l’enregistrement est prêt à démarrer avec le bouton «Démarrer».
- Différentes options sont disponibles une fois l'enregistrement terminé: enregistrer les données dans un fichier ou les imprimer.

Inteface du logiciel
Etape 2: Branchement
 Nous allons réaliser un branchement pour alimenter les cartes et mesurer les consommations. On enfiche les cartes sur une breadboard, puis on les alimente avec un générateur réglé sur 5V. On n’oublie pas le multimètre dans le branchement.
On alimente les cartes et on récolte les données sur une durée de 3 séquences, soit environ 3 minutes afin d’avoir une moyenne à la fin. On enregistre le fichier sous forme Excel (ou autre format).
Afin de d’alimenter les cartes pour réaliser les mesures de l’intensité utilisé, on connecte une source en +5V sur le pin 5V et la masse sur le pin GND de l’arduino Nano [4].
Pour l’ESP32 (avec une carte Adafruit HUZZAH32 - ESP32 Feather), connecter la broche USB au 5V et la masse à la broche GND [5].
Ne pas oublier de brancher le multimètre en série du microcontrôleur et de ne pas utiliser le port USB des cartes arduino ou ESP32 lors des mesures (sous risques d'endommager l'appareil branché en USB) !

                                               

 

Branchements et circuit réalisés
On récolte les données de consommation pour les deux cartes à l'aide du logiciel sur ordinateur.

Etape 3: analyse des données
 Nous analysons ensuite les données en utilisant les bibliothèques python Pandas et Matplotlib avec Python.

Pour pouvoir exploiter le fichier Excel sous Python, il ne faut pas oublier de remplacer les «,»

par des «.».
Le fichier qui nous a permis de faire le graphique est disponible sur le GitHub sous le nom de «plot_conso» [3].

On observe que l'Arduino Nano consomme moins que l'ESP32. Les pics de chaque lignes correspondent à l'allumage de la LED de chaque carte, et l'espace entre chaque pic correspond au mode veille. L'Arduino semble le mieux adapté en terme de consommation.

Arduino
ESP32

mean
6.1727 mA
10.5101 mA

standard deviation
4.6997
11.8473

total time
5.0 min 18.0 s
5.0 min 0.0 s

total time consumption

2981.44 mA

4792.6 mA

average consumption
22.2219 mW/h
37.8363 mW/h

Etape 4: soudure des fils
Nous avons choisi de contrôler la caméra via le connecteur arrière [6] qui permet d’avoir accès à une grande partie des fonctionnalités. Pour utiliser notre connecteur, il nous faut souder des fils dessus.

 

 

 

 

 
Les 30 fils de couleurs différentes     Les pins du connecteur
afin que l’on puisse distinguer les pins
 adjacentes

 Nous allons souder les 30 pins. Il est possible pour plus de facilité de ne souder que les pins concernés, mais le tuto se reposera sur les 30 pins [7].

- Couper et dénuder 30 fils
- Chauffer les fers à souder à 350° (pas trop sinon l’étain fond mal)
- Prendre le fer à souder et plaquer fermement le fil au pin, puis approcher l’étain pour le faire fondre grâce au flux.

 

Brasure de deux pins adjacentes

3.TUTO: Script de la GoPro
 La GoPro Hero 3+S a pour avantage de pouvoir lancer un script présent sur la carte SD dès son allumage. Nous allons configurer la caméra et écrire le script.

Etape 1:

 Allumer la caméra et se rendre dans les paramètres. Chercher l’option «One Button» et la configurer sur OFF.

Configurer au passage la résolution souhaitée pour les photos et vidéos
Etape 2:
Pour le script de la GoPro, il faut enregistrer le fichier sous extension “.ash” . Il est disponible sur notre  GitHub [4]. Le script que nous avons écrit permet de prendre une vidéo et trois photos avant de redémarrer. Disposer de ce script dans la racine de la carte SD/créer un dossier AUTOEXEC qui contiendra le fichier [8]. Enregistrer le fichier sous le nom «autoexec.ash»

Commandes

Utilisation

sleep x

Rendre la caméra inactive pendant x secondes. Temps d’attente

t app appmode video

Passage en mode vidéo de la caméra

t app appmode photo

Passage en mode photo

t app button shutter PR

Enclenchement du bouton déclencheur pour prendre une photo, prendre une vidéo/arrêter une vidéo

Il est intéressant de programmer les séquences en tenant en compte de la batterie et de la capacité de stockage de la carte SD. Pour la GoPro Hero3+S, nous disposons de 64G et d’une batterie d’environ 10 000A. En prenant en compte la taille d’une photo (12MPX) et d’une seconde de vidéo (en 1080p), on peut calculer combien de temps peut tenir notre prototype.

Taille en ko
1 photo

vidéo (1 sec)

GoPro Hero 3+S
4000
5000

On calcule ainsi par approximation le nombre de jour que nous pouvons tenir sous l’eau tout en enregistrant des données avec la formule:
(Capacité de la carte SD) / ( (nombre de photos par jour)*(taille d’une photo) + (temps de vidéo en seconde par jour)*(taille d’une seconde de vidéo) )
Le calcul peut se faire sur une durée d’un mois ou bien d’un an.
Par exemple, pour 10 secondes de vidéos et 24 photos par jour, cela nous fait:
64000000/(24*40000 + 10*5000) = 438,36 soit environ 438 jours, équivalent à environ 14 mois.
Il est aussi possible de calculer la durée en fonction de la consommation de la caméra [9].

4.TUTO: Assemblage du prototype
 Maintenant que nous disposons de tous les éléments dont nous avons besoin, nous pouvons brancher le tout. On branche à l’Arduino NANO sur le pin A0 et le pin GND aux pins de la masse et du bouton d’alimentation (respectivement le pin 30 et le pin 19) [10].
Grâce au programme écrit pour l’Arduino NANO, nous avons programmé des séquences d’allumage de la caméra. Nous avons maintenant une caméra qui prend trois photos toutes les 30 secondes dix fois de suite.

Montage de la Gopro relié à l'Arduino Nano

5. Alternative: ESP32-Cam 

        ESP32-Cam
Pour utiliser une carte SD avec un ESP32-CAM, il est nécessaire de la formater en FAT32 (Attention, même si la carte SD fait plus de 4Go, l’ESP32-CAM ne sait pas gérer plus avec le port intégré)
Programmation d’une séquence de test pour l’ESP32-CAM :

-    Connexion de l’ESP32-CAM avec une cable usb-ttl à l’ordinateur :
o    Broche rx sur u0t
o    Broche tx sur u0r
o    GND sur GND
o    5v sur 5v
o    Relier les broches IO0 et GND
Dans le menu de sélection de la carte, choisir la carte “AI-Thinker ESP32-CAM” et le port COM sur lequel est connecté l’ESP32.
Récupérer le code disponible pour prendre une photo:
https://github.com/ursusnocte/ARE_Curious_Info-Moorev-Timer-Camera/blob/main/ESP32/ESP32_CAM_test_photo/ESP32_CAM_test_photo.ino

ou un équivalent de vidéo, en réalité plusieurs photos par secondes:
https://github.com/ursusnocte/ARE_Curious_Info-Moorev-Timer-Camera/blob/main/ESP32/ESP32_CAM_test_video/ESP32_CAM_test_video.ino

Après cela, il ne reste plus qu’à téléverser le code sur l’ESP32-CAM, si la connexion ne s’effectue pas directement, appuyer sur le bouton de reset du microcontrôleur.
Afin d’afficher les messages envoyées par la carte en débug, ouvrir la console série intégrée de l’IDE et choisir une vitesse de transfert de 115200.

Le code pour photo réalise une photo à chaque allumage ou redémarrage de la carte et celui-ci pour la “vidéo” prend 10 images par secondes dans la configuration actuelle jusqu’au débranchement de la carte.
Pour comprendre plus en détail le fonctionnement des scripts, je vous conseille l’article sur l’ESP32-CAM en référence  [11].

6. Références:
Référence de l’ESP32:
[0] https://www.adafruit.com/product/3405
Téléchargement de l’IDE:
[1] https://www.arduino.cc/en/software
Référence sur les modes de l’ESP32 pour le code:
[2] https://letmeknow.fr/fr/blog/142-tutoriel-les-sleep-modes-de-lesp32
Lien vers notre GitHub:
[3] https://github.com/ursusnocte/ARE_Curious_Info-Moorev-Timer-Camera

Lien pour alimentation de l’Arduino:
[4]https://idehack.com/alimenter-larduino-nano/
Lien pour branchement ESP32:
[5] https://learn.adafruit.com/adafruit-huzzah32-esp32-feather/power-management
Lien vers le modèle du connecteur Herobus:
[6] https://www.digikey.fr/en/products/detail/jae-electronics/DD1P030MA1/1283154
Lien vers les descriptions des pins du connecteur arrière de la caméra:
[7] https://mewpro.cc/en/2014/10/14/herobus-pinout-of-gopro-hero-3-black/
Référence autoexec scripts:
[8] https://github.com/KonradIT/autoexechack
Lien vers les informations concernant le connecteur herobus:
[10] https://github.com/KonradIT/gopro-herobus-sdk/blob/master/diyprojects.md
Lien vers le site de Camdo sur la batterie des caméras:
[9] https://cam-do.com/pages/power-consumption-by-gopro-camera-model
Lien vers l’article sur l’ESP32-Cam :
[11] https://randomnerdtutorials.com/esp32-cam-take-photo-save-microsd-card/Journal de bord MOOREV-Timer-Camera ScFo

Journal de bord:
06/03:
- Pour notre système il faut que l'on choisisse entre l'Arduino NANO et l'ESP32 en se basant sur leur consommation en énergie. Il faut que l'on puisse mesurer la consommation en énergie sur différentes séquences et différentes durée.

09/03: [séance Fablab]
- Durant la séance nous avons discuté du projet et en quoi le Fablab peut nous aider. Réflexion sur les tests et les protocoles à réaliser pour la consommation de la batterie avec les deux cartes, avec recherches sur la mise en veille des cartes. Recherches sur les aspects de la GoPro Hero3+ et comment la manipuler avec un programme implanté. Réflexion sur les durées et les séquences d'enregistrements pour la caméra.
- Visite de l'atelier Fablab partie électronique, avec présentation du matériel mis à disposition. Préparation du matériel pour la prochaine séance au Fablab.

10/03: [séance Fablab]
- Point et vu d'ensemble sur tout le matériel que nous possédons.
- Point sur la façon de relier le micro processeur à la GoPro. Recherches sur le port Hero de la GoPro Hero 3+ qui nous permet de conclure sur l'utilisation du port Hero pour contrôler de manière filaire la caméra. Recherche de références afin de pouvoir trouver et se procurer un branchement compatible au port Hero.
Liens:
Autre possibilité pensée de connecter la GoPro qui nécessite la modification de la caméra (idée mise de côté):
https://hackaday.io/project/12108-gopro-hero-4-wired-control
https://www.youtube.com/watch?v=mpPfk4sLb3I
Informations sur le port Hero Bus de la GoPro Hero:
https://wiki.logre.eu/index.php/GObotPRO
17/03: [séance Fablab]
- Réunion afin de préparer les tests de consommation d'énergie entre l'Arduino Nano et l'ESP32. Acquisition du matériel nécessaire, et codage des cartes.
- Tests (code) du nombre de cycles par minutes possible sur l'Arduino qui va permettre d'allumer et d'éteindre la caméra.
- Emprunt d'un ESP32 qu'on a du souder au labo électronique.
- Création d'une page GitHub afin de déposer notre code et recherches sur le mode hibernation de l'esp32 ainsi que la façon de récupérer les données d'un multimètre sur l'ordinateur afin d'enregistrer les données.
24/03: [séance Fablab]
- Prise de mesures des consommations.
- Programmation de l'ESP32 en mode basse consommation, mise à disposition du code sur Github. Réalisation d'un montage sur planche de prototypage pour mesurer la consommation des microcontrôleurs avec un multimètre.

(Lien vers le GitHub)
- Téléchargement d'un logiciel lié au multimètre afin de le connecter à ce dernier pour récolter en temps réel les données mesurées.

- Réalisation des tableaux Excel avec les résultats.
31/03: [Séance Fablab]
- Réception du matériel nécessaire (ESP32-CAM et port Hero) pour connecter le microcontrôleur à la GoPro.
- On procède ensuite à la soudure de fils sur le port de chaque pins afin de pouvoir accéder aux pins
- Réflexion sur la programmation de l'ESP32-Cam
- Calcul sur tableau Excel des différentes séquences possible en prenant en compte la capacité de stockage de la carte SD et de la taille d'une vidéo/photo.
Tableau de séquence dans le répertoire GitHub: Lien vers le GitHub
04/04: [Séance Fablab]
- Continuation de la soudure des pins sur le connecteur
- Programmation de l'ESP32 Cam et test des photos. Mesure de leur capacité de stockage photos et vidéos. Rencontre d'un problème: ESP32 cam -> focal fixe par défaut avec le capteur OV2640, à remplacer par un autre capteur plus adapté (lien vers le capteur).

- Test des pins du connecteur et confirmations des ports (port 19 pour allumage de la caméra). Test lancer un script sur carte SD en allumant la GoPro.

07/04: [Séance Fablab]
- Nous avons constaté que la soudure n'a pas tenue et que des broches ont été cassé lors de la manipulation. Nous réfléchissons donc à un autre moyen de souder des fils moins rigides, ou bien à une alternative.
- Le but de la séance était d'allumer la GoPro à l'aide de l'arduino et du port Hero, et de vérifier que le script se lançait à l'allumage de la caméra. Nous rencontrons toutefois un problème concernant la lecture du script, que la caméra ne détecte pas.

14/04: [Séance Fablab]
-Tests du fonctionnement du script sur la GoPro. Préparation de la présentation à l'oral et des comptes rendus concernant l'UE.
Le script lancé est disponible sur le répertoire GitHub sous le nom de 'autoexec.ash'.
(Lien vers le GitHub)

(Une fois que nous pouvons connecter l'Arduino à la GoPro, nous devons nous assurer que la GoPro lit bien le script présent sur la carte SD dès l'allumage. Pour cela, nous allons déposer dans la racine de la carte un fichier sous le nom de 'autoexec.ash' et qui contient les instructions.

)
18/04: [Séance Fablab]
Dernière séance avant le rendu des travaux. Nous avons testé une dernière fois le lancement du script sur la GoPro en branchant le tout sur l'Arduino. Nous avons fait face à quelques problème au niveau des branchements qui n'allumait pas la caméra. Le problème a été résolu à la fin grâce à l'aide d'un chercheur présent au Fablab.
Le prototype fonctionne, il ne reste qu'a programmer la bonne séquence sur le script de la GoPro.Journal de bord MOOREV-Stéréovision_Calibration

Journal de bord:
Vendredi 7 avril:
-On a imprimer préalablement des échiquier pour la calibration.
-On a utiliser les 2 Gopros Heroes 3+ pour prendre des photos.
-On a placé les caméras et l'échiquier à une distance de 20cm

-On a pris des photos de l'échiquier dans plusieurs angles.
-On les a trier et séparer par photo droite et gauche,

-On a calibré les photos grâce a l'application "Stereo Camera Calibrator" de MatLab

Mardi 11 avril:
-On refait de la calibration, on réduit la marge d'erreur de la reprojection pour être environ en dessous de 10 pixel

🖋️ MU5MN045 - Atelier conception 3D et 2D

Master Management de l'Innovation
S2 2022-2023

Consignes

Semaine 1
Modélisation 3D, Modélisation 2D, Impression 3D

Créer un modèle 3D de porte-savon en deux parties (grille et contenant), le préparer pour l'impression et l'imprimer.
Logiciels à utiliser

Inkscape pour créer un ou plusieurs éléments 2D à extruder (a minima une grille du porte-savon, en option un logo)

les modèles doivent être exportés en .svg

Tinkercad pour la modélisation 3D

les modèles doivent être exportés en .stl

Ideamaker pour slicer vos modèles 3D

le fichier exporté sera sous forme de .gcode

La documentation doit contenir des captures d'écran des différentes étapes de conception, avec quelques lignes d'explication.
Vous devez également ajouter vos fichiers sources à votre documentation : .svg, .stl, .gcode
Vendredi : présentation de la documentation, les fichiers doivent être finalisés et importés.
Dans l'idéal, avoir son projet imprimé.Ryan Vicente

Projet porte-savon

Le but du projet

Pour cette première semaine de cours, le premier mini-projet à réaliser est un porte-savon imprimé en 3D. Pour réaliser cette impression. Nous allons créer deux structures :

Une base 'contenant' designée en 3D sur Tinkercad
Une grille à déposer dans le contenant désignée en 2D sur InkScape

Le but est de créer une structure fonctionnelle qui permet à l'eau de s'écouler sans que le savon ne se ramolisse. Une fois les patrons réalisée, la structure sera imprimée à l'aide d'IdeaMaker.
La base du porte-savon

La base du porte savon est composée de plusieurs blocs de bases présents sur Tinkercad. Pour réaliser la structure de base :

J'ai créer un cube allongé ayant les bords arrondis

J'ai utilisé un second cube de perçage allongé ayant des bords droits afin de trouer le premier bloc (via une union) tout en laissant un fond

Il a été décidé de mettre en place un robinet sur l'un des angles de la structure afin de faciliter l'écoulement de l'eau lors du versement de l'eau stagnante. Pour réaliser ce robinet il a fallu :

Créer un cylindre et le déposer dans l'un des coins de la base

Créer un second cylindre de perçage pour trouer le cylindre

Le résultat de ces premières opérations a donné :

J'ai ensuite pu ajouter des cales pour placer la grille sur le porte-savon à l'aide de triangles rectangles placés sur la partie interne de la base :

La base a été réalisée en différentes versions :

Avec porte-blaireau

Avec grille intégrée

Sans robinet et avec grille intégrée

Pour l'exercice, la version de base qui sera utilisée est la version classique avec robinet.
La grille du porte-savon

Afin de réaliser la grille du porte-savon j'ai utilisé InkScape. À l'aide de cette plateforme OpenSource et libre, j'ai pu réaliser le motif de ma grille en 2D, en utilisant des motifs de bases tels que le rectangle et le polygone.

Créer un rectangle dans les mesures souhaitées
Dessiner le motif souhaité à l'aide des formes de bases disponibles

Une fois les formes superposées sur le rectangle à l'endroit adéquat, utiliser le booléen 'Différence' afin de soustraire le motif au rectangle et ainsi créer la grille

La grille mesure 110mm sur 80mm pour correspondre aux mesures de la plus part des savons

Le document vectoriel (.svg) ainsi issu d'InkScape peut être extrudé sur Tinkercad à côté de la base du porte-savon.
Si la grille n'arrive pas à s'uploader sur Tinkercad, il faut faire une capture d'écran de la grille 2D et faire passer cette capture d'objet matriciel à vectoriel sur InkScape. Il faut ensuite uploader ce nouveau document sur Tinkercad.

Mesures en millimètres
Mise en impression

Une fois les deux éléments regroupés sur le même document Tinkercad (.stl), ils peuvent être modélisés en 3D sur IdeaMaker pour préparer l'impression 3D. L'impression sera alors modélisée sur un document .Gcode (langage des machines outils) :

Caractéristiques d'impression

Afin d'imprimer le porte-savon, nous allons privilégier un remplissage à 10% afin d'apporter une certaine solidité à l'objet qui sera utilisé sans utiliser trop de matière (et ne pas rendre le coût de production trop élevé).

Pour optimiser la résistance et la dureté du porte-savon, il est judicieux de l'imprimer en 3-4 coques.
Du point de vue de l'adhérence, il semblerait qu'il n'y ai pas besoin de mettre des supports (ou de bords) en place pour l'impression.

La hauteur de la couche restera 0,25mm par défaut.
Temps d'impression estimé : 6h 44min 49sec
Coût estimé d'impression : 2,36€

Quantité estimée : 78,6g / 26,35m

Le prix moyen d'un porte-savon étant de 5€ il est possible de vendre le porte-savon au double du coût de production à minima.
Documents sources (joints à la page)

Grille du porte-savon (.svg)
Porte-savon (.stl)

Réaliser un montage électronique Arduino

Le but du projet

Le deuxième cours consiste en l'apprentissage de l'électronique à travers la modélisation de circuit Arduino sur Tinkercad. Après avoir compris les bases de la conception électronique, le but du cours est de pratiquer sur de vrais circuits à l'aide de l'application Arduino afin de pouvoir automatiser des actions et apporter de la complexité et de nouvelles fonctionnalités à nos prototypes. Dans ce cours, nous utiliserons des Arduino Uno. L'ensemble des modalités et convention relatives à l'Arduino sont disponibles sur le lien 'Introduction à l'Arduino' ci-joint.
La loi d’Ohm

La loi d'Ohm est la loi de base en électronique. C'est une loi physique empirique qui lie l'intensité du courant électrique traversant un dipôle électrique à la tension à ses bornes. Cette loi permet de déterminer la valeur d'une résistance.

U = R*I

U la tension aux bornes de la résistance ;
I l’intensité du courant qui circule à travers la résistance ;
R la valeur de la résistance.

Codes

Programme Blink (débutant)

#define LED 10
int compteur = 0;
void setup()
{
Serial.begin(9600); // permet de dire que l'on va initier une communication entre l'ordinateur et le circuit à la vitesse 9600 
pinMode(LED, OUTPUT); // déclaration de la pin 10 comme sortie
}
void loop()
{
Serial.print("Debut de la boucle ");
Serial.println(compteur);
digitalWrite(LED, HIGH);
delay(1000); // ne rien faire pendant 1000ms
digitalWrite(LED, LOW);
delay(1000); // ne rien faire pendant 1000ms
compteur++; // incrémentation du compteur
}

Le programme Blink est le programme de base que les étudiants en électronique apprennent en premier afin de s'exercer. Il permet de comprendre comment :

Utiliser le format Java

void setup() 
{
}

void loop() 
{
}

Définir une pin : Annoncer à l'ordinateur sur quelle partie de l'Arduino (numéro de la pin connectée) est connecter le composant auquel nous allons donner des informations (ou duquel nous allons prendre les informations).

#define LED 10 
// La led est connectée sur la pin 10

Annoncer la communication entre l'ordinateur et le circuit

Serial.begin(9600)

Utiliser une première fonction d'action

digitalWrite(LED, HIGH);
// Permet d'allumer la led `
delay(1000)
// Ne rien faire pendant 1000ms
Programme Bouton

#define BTN 8

void setup()
{
 pinMode(BTN, INPUT_PULLUP);
 
 Serial.begin(9600);
}

void loop()
{
 if( digitalRead(BTN) == LOW )
 {
 Serial.println("Button pressed");
 }
 
 delay(100);
}

Le programme Bouton fait intervenir un bouton dans le circuit. Cela permet d'introduire le code des boucles conditionnelles if.
Programme Buzzer

#define POT A0
#define BUZZ 9

void setup()
{
 pinMode(POT, INPUT);
 pinMode(BUZZ, OUTPUT);
 
 Serial.begin(9600);
}

void loop()
{
 int pot = analogRead(POT);
 Serial.println(pot);
 
 // int buzzfreq = map(pot, 0, 1023, 1000, 20000);
 
 // tone(BUZZ, buzzfreq);
 // delay(1000);
 // noTone(BUZZ);
}

Programme moteur

Pour tester en pratique nos connaissances acquises lors de la matinée de théorie. J'ai décidé de travailler sur la mise en place d'un circuit électronique composé d'un servomoteur (permettant une rotation de 180°). Le but de ce circuit est d'apprendre à manipuler les composants électronique et de se familiariser avec la recherche de code et de prendre en main la plateforme de programmation Arduino.
Le servomoteur a été branché à l'Arduino selon les modalités suivantes :

L'alimentation V a été connectée au 5V de l'Arduino à travers le breadboard
La masse GND a été connectée au ground de l'Arduino à travers le breadboard
Le signal S a été connecté à la pin 8 de l'Arduino

Sur cette photo il est possible de distinguer un quatrième câble marron qui sort du servomoteur. Ce câble permet de connecter une alimentation externe au servomoteur (ce qui n'est pas nécessaire ici.)
Le code suivant a été utilisé pour faire tourner la tête rotative du servomoteur trois fois :

De 0° à 90°
De 90° à 180°
De 180° à 0°

#include <Servo.h> // on inclut la bibliothèque servo

Servo servoMoteur; // on crée un objet servo appelé servoMoteur

void setup(){ 
 // on associe le servo à la broche 2 d'Arduino
 servoMoteur.attach(8);
}
 
void loop(){
 // on déplace le servo à la position 0º
 servoMoteur.write(0);
 delay(1000); // pause de 1 seconde
 
 // on déplace le servo à la position 90º
 servoMoteur.write(90);
 delay(1000); // pause 1 seconde
 
 // on déplace le servo à la position 180º
 servoMoteur.write(180);
 delay(1000); // pause 1 seconde
}

Programme Capteur & Moteur

Afin de complexifier l'exercice, il a été décidé de rajouter un capteur infrarouge au circuit afin d'activer le moteur lorsqu'un objet est détecté par le capteur. Pour cela, le capteur a été connecté à l'alimentation et à la masse de l'Arduino à travers le breadboard et le signal a été dirigé vers la pin 10 de l'Arduino.
Le code suivant a permis de mettre en place le montage afin de faire tourner le moteur quand un objet est détecter par le capteur :
#include <Servo.h> // on inclut la bibliothèque servo
int inputPin = 10; // choose the input pin (for sensor)
int pirState = LOW; // we start, assuming no motion detected
int val = 0; // variable for reading the pin status

Servo servoMoteur; // on crée un objet servo appelé servoMoteur

void setup(){ 
 // on associe le servo à la broche 2 d'Arduino
 servoMoteur.attach(8);
 pinMode(inputPin, INPUT); // declare sensor as input
 Serial.begin(9600);
 Serial.print("calibrating sensor ");
}
 
void loop(){
 val = digitalRead(inputPin); // read input value
 Serial.println(val);
 if (val == HIGH) { // check if the input is HIGH
 // on déplace le servo à la position 0º
 servoMoteur.write(180);
 } else {
 servoMoteur.write(0); // turn motor OFF
 }
}

Claire Huang

Semaine 1
Mardi 14 février 2023
Modélisation d'un porte savon :
Modèle souhaité :

Modélisation 3D sur Tinkercad :
Dimensions : 120 mm /100 mm pour le support du savon, 15 mm pour les pieds

Création d'un demi-cylindre puis superposition avec un cylindre de dimension inférieure de 10 mm environ en hauteur, largeur et longueur

Création d'un nouveau plan sur le dessus des pieds : copier/coller le cylindre dans ce nouveau plan :

Intégrer des motifs avec le dossier 2D issu d'Inskape :

Mettre le motif au même plan que le support et l'intégrer dedans :

Pour l'impression :
Couche en hauteur : 2 mmRemplissage : 10%Adhérence : support
Temps d'impression estimé : 12h 28 minQuantité estimée : 119,3g/ 39.99mPrix estimé : 3€58
Résultats :Essaies : 3Problèmes : (1) adhérence, (2) qualité du fil, (3) problème de fil

Semaine 2
Lundi 06 mars 2023
Electronique

LAMPES :
#define LED_1 10
#define LED_2 9

int compteur = 0;

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

 pinMode(LED_1, OUTPUT);
 pinMode(LED_2,OUTPUT);

}

void loop() {
 Serial.print("Debut de la boucle");
 Serial.println(compteur);

 digitalWrite(LED_1, HIGH);
 delay(1000);
 digitalWrite(LED_1,LOW);
 delay(1000);

 digitalWrite(LED_2, HIGH);
 delay(1000);
 digitalWrite(LED_2,LOW);
 delay(1000);

 compteur++;

}

Soamalala Rajaonarison

13/02/2023 : Modélisation 2D et prise en main d'Inkscape

14/02/2023 :

Projet de modélisation d'un porte savon

Concept pensé : Porte savon en forme de cœur en 2 pièces
Outils utilisés : Tinkercad ; Inkscape
Inspiration : soap holder-things - Search - Thingiverse

Etape 1 : création du support de base
L : 12 cm / l : 10 cm / h : 2,5 cm
--> Bloc cœur > bloc cœur vide > assemblage
   
Etape 2 : création de la sortie d'eau
Insertion d'un cylindre vide et regroupement
   
Etape 3 : création des supports de la 2ème pièce

Etape 4 : création de la deuxième pièce en 2 D sur Inkscape
- Importer une image de cœur sur le logiciel
- Le vectoriser
Dimension de la maille :  104 / 90

Fusionner les formes et exporter le format .svg

Etape 5 : Importer le fichier à Tinkercad

Problématique : Je me suis rendue compte que mes 4 petits supports arrondis n'allaient pas pouvoir soutenir la 2ème pièce
Etape 6 : Modification des 4 supports --> rectangulaire
 

Etape 7 : Modèle 3D final

Etape 8 : Impression au fablab
Les caractéristiques :

06/03/2023 : 
Electronique de prototypage (Arduino)
Signal analogique =/= Signal numérique (1011)
Electronique numérique : loi d'Ohm : U=RxI
Pour que le courant fonctionne (pile), le circuit doit être fermé :

Symboles (cf photo) : Flèche vers le haut : + // Masse (terre?) : vers le bars
Résistance : pas de sens de branchement
May led : partie courte (cathode doit être connectée au -)

digitalWrite(LED, HIGH)= numéro, état (haut/bas)
Si on rajoute d'autres led, need plus de résistance

*port de série connecté à une résistance puis led

Conditions :
if (condition vérifiée) {
instructions (  ) ;
}

volume =40 // affecter
if (volume == 40) // tester
{

}

Inspo : Ultrasonic Sensor HC-SR04 and Arduino - Complete Guide (howtomechatronics.com)

Test Programme Blink
#define LED 4

void setup() {
 // put your setup code here, to run once:
 pinMode(LED, OUTPUT);
 Serial.begin(9600);

}

void loop() {
 // put your main code here, to run repeatedly:
 digitalWrite(LED, HIGH);
 delay(1000); // ne rien faire pendant 1000ms
 digitalWrite(LED, LOW);
 delay(1000);
}

Test Capteur Distance
const int trigPin = 8;
const int echoPin = 11;
const int LED = 4;
// defines variables
long duration;
int distance;

void setup() {
 pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
 pinMode(echoPin, INPUT); // Sets the echoPin as an Input
 pinMode(LED, OUTPUT);
 Serial.begin(9600); // Starts the serial communication
}

void loop() {
 // Clears the trigPin
 digitalWrite(trigPin, LOW);
 delayMicroseconds(2);
 // Sets the trigPin on HIGH state for 10 micro seconds
 digitalWrite(trigPin, HIGH);
 delayMicroseconds(10);
 digitalWrite(trigPin, LOW);
 // Reads the echoPin, returns the sound wave travel time in microseconds
 duration = pulseIn(echoPin, HIGH);
 // Calculating the distance
 distance = duration * 0.034 / 2;
 // Prints the distance on the Serial Monitor
 Serial.print("Distance: ");
 Serial.println(distance);
 
 if (distance >= 250)
 {
 digitalWrite(LED, HIGH);
 }
 else
 {
 digitalWrite(LED, LOW);
 }
}

Aurélie LAMARRE

Projet 1 : Porte savon
Introduction :

Ce projet a débuté le 14 février 2023 et a une fin estimée fin février 2023.
Les objectifs sont les suivants : réaliser un porte savon en 2 parties, d'une part la grille et d'autre part le récipient. Le but est de se familiariser avec la modélisation 2D grâce au logiciel Inkscape, ainsi qu'avec la modélisation 3D en utilisant le logiciel Tinkercad. Ensuite, l'impression se fera avec le logiciel IdeaMaker et il faudra donc déterminer les bons paramètres d'impression.

Journal de bord :
Etape 1 : Modélisation 2D de la grille
Pour la grille j'ai choisi de réaliser un motif de visage de femme tracé en une ligne à la main. Pour dessiner ce motif, j'ai commencé par trouver sur Google image le dessin qui me plaisait le plus, que j'ai ensuite importé au format png dans le logiciel Inkscape. Puis, avec l'outil de dessin à main levée, j'ai repassé les traits afin de créer mon propre dessin. Une fois fait, j'ai supprimé le fichier png.

Afin de corriger certains détails qui n'étaient pas suffisamment arrondis, j'ai utilisé la fonction "Convertir les formes en chemin" afin de manipuler différents nœuds pour avoir les courbes souhaitées. J'ai ensuite mis un cadre rectangulaire autour de mon dessin, avec un rayon de 20 mm au niveau des coins, et après avoir sélectionné les deux objets, je les ai groupé. J'ai fini par régler l'épaisseur des traits ainsi que les dimensions de la grille (123x73mm). J'ai ensuite enregistré le fichier au format svg.
Etape 2 : Modélisation 3D du contenant
Ici il s'agit de procéder à la construction du contenant. Pour cela je me suis connectée sur le logiciel 3D Tinkercad.
La première étape a été d'utiliser un cube auquel j'ai mis les dimensions souhaitées (130x80x30mm). Puis, j'ai réalisé un second cube avec la fonction Perçage, aux proportions légèrement plus réduites afin de creuser le porte savon. Pour que ces deux objets soient bien alignés, je les ai tous deux sélectionnés et cliqué sur le bouton Aligner avant d'utiliser les bonnes commandes pour bien centrer ces objets. J'ai aussi donné le bon rayon de coins à la forme ayant permis de creuser le trou.

J'ai ensuite souhaité importer ma grille, mais j'ai cependant été confrontée à un problème. En effet, il se trouve que lors de mon importation le remplissage de mon motif était inversé : les lignes étaient creuses et le fond était rempli. La solution a été la suivante : je suis retournée sur Inkscape, ai enregistré mon fichier au format png avant de le réimporter sous ce nouveau format dans Inkscape. Puis, j'ai utilisé la fonction "Vectoriser un objet matriciel". Un fois fait, j'ai supprimé le motif initial pour garder seulement le nouveau format matriciel généré, avant d'enregistrer ce fichier au format svg.
Cette manipulation m'a permis d'avoir ma grille telle que je la souhaitais dans Tinkercad

Pour une question pratique j'ai finalement enlevé temporairement les rayons du trou afin de créer les supports sur lesquels la grille va reposer. J'ai crée 6 petits bâtonnets en sélectionnant la forme souhaitée sur le menu de droite (cf capture), et afin de bien les aligner j'ai une nouvelle fois utilisé la fonction Aligner.

J'ai ensuite remis les rayons, disposé la grille sur le contenant et créé le tunnel via lequel l'eau accumulée dans le contenant pourra être vidée. Pour cela j'ai utilisé la forme cylindre, avec la fonction Perçage et je l'ai disposée comme souhaité.

Puis, j'ai souhaité apporter un élément supplémentaire en inscrivant le mot "Savon" de façon creusée sur le contenant. J'ai utilisé l'élément Texte, inscrit mon mot et utilisé la fonction Perçage avant de bien le disposer sur la paroi.

Voici le rendu final :

Etape 3 : Choix des paramètres d'impression
J'ai exporté cette modélisation au format stl. La fenêtre d'IdeaMaker raise 3D E2 s'est ouverte. Dans le menu "tabulation" j'ai pu inscrire les paramètres d'impression :

Hauteur de couche : 0,25 mm, cela me semble correct pour un projet de ce type
Coque : 2,5 pour que les parois soient un minimum solides
Densité de remplissage : 10% car les formes ne sont pas "fragiles" et ne nécessitent pas de rigidité de structure particulière.
Générer des supports : aucun car les objets imprimés ne sont pas trop "sensibles"
Aide à l'adhérence : aucun car ce n'est pas nécessaire pour les objets imprimés non plus

Etapes à venir :
Impression du porte savon

Projet 2 : Détecteur d'objet
Introduction :

Ce projet a été réalisé le 6 mars 2023 en binôme.
Les objectifs sont les suivants : réaliser un circuit avec modélisation préliminaire sur le logiciel Tinkerpad et réalisation manuelle avec le logiciel Arduino.

Journal de bord :
Etape 1 : Modélisation 2D du circuit
Nous avons trouvé sur le site suivant notre fichier source avec le tutoriel pour réaliser le circuit :
https://howtomechatronics.com/tutorials/arduino/ultrasonic-sensor-hc-sr04/?utm_content=cmp-true
A cela, nous avons ajouté à cela une résistance ainsi qu'une led avec pour objectif qu'elle s'allume en fonction de la distance d'un objet du capteur de distance.
Création du circuit à l'aide du logiciel TinkerCad ainsi que du code pour vérifier que les branchements et le code fonctionnent bien.

Etape 2 : Création manuelle
Construction réalisée avec les outils et accessoires mis à disposition au fablab.
Etape 3 : Test
Connexion au logiciel Arduino IDE 2.0.3 et branchement à l'Arduino.
Après avoir réalisé le branchement de l'Arduino le code suivant a été renseigné dans le logiciel :
#define LED 8

const int trigPin = 9;
const int echoPin = 10;

long duration;
int distance;

void setup() {
 // put your setup code here, to run once:
 pinMode(trigPin, OUTPUT);
 pinMode(echoPin, INPUT);
 pinMode(LED, OUTPUT);
 Serial.begin(9600);
}

void loop() {
 // put your main code here, to run repeatedly:
 digitalWrite(trigPin, LOW);
 delayMicroseconds(2);

 digitalWrite(trigPin, HIGH);
 delayMicroseconds(10);

 digitalWrite(trigPin, LOW);

 duration = pulseIn(echoPin, HIGH);
 distance = duration * 0.034 / 2;

 if (distance < 5){
 digitalWrite(LED, HIGH);
 } else {
 digitalWrite(LED, LOW);
 }

 
}

Résultat :

PIRUS Marine

Porte savon
Objectif du projet

L'objectif de ce projet est de réaliser une boite à savon à l'aide de l'outil Tinkercad en 3D mais aussi de réaliser une grille en 2D
ETAPE 1 : Création de la boîte en 3D

Le fichier du porte-savon en .stl

Création de la boite d'une taille de 11 cm sur 7 cm avec la forme rectangle à laquelle j'ai arrondi les bords grâce au diamètre

Création du deuxième rectangle que j'inclus dans la première boîte.  Puis on passe la deuxième boîte (orange) en mode perçage

Création de la gouttière en forme de moustache ici pour que l'eau s'évacue. Cet élément a été aussi mis en mode perçage puis tout à été groupé.

Création des taquets afin de disposer la grille que l'on va réaliser en 2D. Les taquets ont été réalisé à l'aide de l'outil triangle rectangle.

ETAPE 2 : Création de la grille
Le fichier de la grille en .svg 

La grille a été réalise avec Inskcape à l'aide de forme hexagonale sur une forme rectangulaire qu'on l'on dissocie à chaque fois.

Rendu final sur Tinkercad

Voici le rendu lorsque l'on a importé la grille au format svp dans Tinkercard.

Rendu final avec la grille posée sur la boite à savon.

ETAPE 3 : Télécharger sur IdeaMaker
Le fichier final contient la grille et le porte savon en .gcode
Caractéristiques de mon impression :

hauteur de couche : 0,25 mm : je ne l'ai pas changé j'ai laissé ce qui était par défaut
nombre de coques : 4 : j'ai choisi d'en mettre 4 afin que mon objet soit bien résistant

densité du remplissage : 15%

aide à l'adhérence : aucun car je pense qu'il y a pas besoin d'aide à l'adhérence pour ce type d'objet

Pour finir j'ai pu voir que le temps estimé de l'impression était d'environ 9h.
Montage électronique Arduino
Branchement d'un servomoteur
Avec Ryan, nous avons décidé de travailler sur la mise en place d'un circuit électronique composé d'un servomoteur (permettant une rotation de 180°).
Le servomoteur a été branché à l'Arduino selon les modalités suivantes :

L'alimentation V a été connectée au 5V de l'Arduino à travers le breadboard
La masse GND a été connectée au ground de l'Arduino à travers le breadboard
Le signal S a été connecté à la pin 8 de l'Arduino

Ce schéma ci dessus montre le branchement du servomoteur.
Le code suivant a permis de faire tourner la tête 3 fois :

de 0 à 90°
de 90 à 180°
de 180 à 0°

#include <Servo.h> // on inclut la bibliothèque servo

Servo servoMoteur; // on crée un objet servo appelé servoMoteur

void setup(){ 
 // on associe le servo à la broche 2 d'Arduino
 servoMoteur.attach(8);
}
 
void loop(){
 // on déplace le servo à la position 0º
 servoMoteur.write(0);
 delay(1000); // pause de 1 seconde
 
 // on déplace le servo à la position 90º
 servoMoteur.write(90);
 delay(1000); // pause 1 seconde
 
 // on déplace le servo à la position 180º
 servoMoteur.write(180);
 delay(1000); // pause 1 seconde
}
Ajout d'un capteur

Nous avons par la suite décidé d'ajouter un capteur infrarouge un circuit afin d'activer le moteur lorsqu'un objet est détecté par le capteur. Pour cela, le capteur a été connecté à l'alimentation et à la masse de l'Arduino à travers le breadboard et le signal a été dirigé vers la pin 10 de l'Arduino.
Ann-Rachel Ngambi

Semaine 1 - Modélidation 2D, 3D et Impression 3D d'un porte savon
Etape 1 : Modélisation 2D de la grille du porte savon sur INKSPACE
J'ai commencé par paramétrer le document sur une taille 12x8 cm afin d'obtenir un porte savon assez grand.

J'ai tracé mon motif à l'aide l'outil "courbes de Bézier". Je souhaitais une grille asymétrique.

J'ai ensuite modifié l'épaiseur de mon tracé et je l'ai transformé en "contour en chemin".

J"ai ajouté le contour de mon porte savon.

J'ai découpé ma grille selon la forme de mon savon grâce à l'intersection de chemins et j'ai transformé mon contour en chemin pour pouvoir l'unir au chemin de ma grille.
Pour finir j'ai enregistré ma grille au format svg.
Etape 2 : Modélisation 3D du porte savon sur TINKERCAD
J'ai commencé par choisir un modèle qui me plaisait sur le site thingiverse.com .

Après l'avoir téléchargé, je l'ai importé dans Tinkercad.

J'ai également importé ma grille.

J'ai modifié les dimensions de ma grille afin de m'assurer qu'elle corresponde bien au socle de mon porte savon.

J'ai ensuite ajouté un renard sur un socle circulaire que j'ai unifié avec le socle du porte savon.

J'ai ensuite séparé la grille du socle et j'ai exporté au format .stl pour l'impression.

Etape 3 : Impression 3D du porte savon à l'aide d'IDEAMAKER
J'ai commencé par paramétrer mon fichier d'impression avec une densité de remplissage de 10%, des supports et sans aide à l'adhérence.

J'ai importé mon modèle et j'ai réparé les erreurs indiquées.

J'ai ajouté les supports puis j'ai exporté le fichier au format .gcode

Semaine 2 - Création d'un circuit électronique

/*
 Ultrasonic Sensor HC-SR04 and Arduino Tutorial

 by Dejan Nedelkovski,
 www.HowToMechatronics.com

*/
// defines pins numbers

#define LED 8
const int trigPin = 9;
const int echoPin = 10;
// defines variables
long duration;
int distance;
void setup() {
 pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
 pinMode(echoPin, INPUT); // Sets the echoPin as an Input
 pinMode(LED, OUTPUT);
 Serial.begin(9600); // Starts the serial communication
}
void loop() {
 // Clears the trigPin
 digitalWrite(trigPin, LOW);
 delayMicroseconds(2);
 // Sets the trigPin on HIGH state for 10 micro seconds
 digitalWrite(trigPin, HIGH);
 delayMicroseconds(10);
 digitalWrite(trigPin, LOW);
 // Reads the echoPin, returns the sound wave travel time in microseconds
 duration = pulseIn(echoPin, HIGH);
 // Calculating the distance
 distance = duration * 0.034 / 2;
 // Prints the distance on the Serial Monitor
 Serial.print("Distance: ");
 Serial.println(distance);
 
 if( distance <=30 )
 {
 digitalWrite(LED, HIGH);
 }
 else
 {
 digitalWrite(LED, LOW);
 }
 
}
Shabneez Elaheebucus

PORTE SAVON

PARTIE 1 : CRÉATION DU PORTE SAVON
Première étape :  Création du cylindre

Deuxième étape : Définition des dimensions
Longueur du cylindre : 100mm

Largeur du cylindre : 60mm

Hauteur du cylindre : 30 mm

Mise en place du cylindre pour le perçage :

Le cylindre pour le perçage a été mis au centre du cylindre solide, j'ai laisser 10mm d'épaisseur pour le fond du cylindre solide.

Voici le cylindre solide après perçage :

Je souhaite également faire un perçage pour l'évacuation de l'eau, je choisis de le faire sur la face avant de mon porte-savon : 

Je le place à 10mm de hauteur sur la face avant : 

je perce ensuite le cylindre :

Je perce le canaux d'évacuation d'eau pour laisser sortir l'eau :

Je place ensuite le cadeau d'évacuation sur le cylindre et associe les 2 éléments :

Je place ensuite 2 triangle où reposera la grille du porte savon : hauteur = 16 mm

Voici le porte savon avant la mise en place de la grille :

PARTIE 2 : CRÉATION DE LA GRILLE

Sur Inkscape, je commence a créer la grille du porte savon :

Je trace premièrement un cercle avec les mêmes dimensions que celles de mon cylindre :

Rx = 100mm et Ry = 60 mm 

Par la suite je décide de faire les espace d'évacuation en choisissant une forme avec 6 sommets :

Je superpose ensuite mes formes de manière à remplir ma grille :

Je place ensuite mes formes dans le contour de ma grille :

J'importe ensuite ma grille sur Tinkercad :

Je redimensionne ma grille afin qu'elle soit à la bonne dimension pour être intégrée dans le porte savon :

Je place ensuite ma grille à la bonne hauteur :

Je place la grille à la bonne hauteur sur les supports :

Voici le porte-savon finalisé :

Wiem Mansouri

Projet Porte savon en impression 3D
Étape n°1 : la création du support

Dans un premier temps, j'ai tracer la forme sur Inkscape pour avoir les bonnes dimensions, le savon faisant à peu près 5X8 cm j'ai donc créer un modèle mesurant 10x6 cm  
J'ai ensuite importer les deux fichiers dans les bonnes dimensions dans Tinkercad ( Le support en forme cylindrique et les une forme identique en plus petite pour faire le perçage)

je les ai ensuite superposé et percé avec la forme plus petite

j'ai ensuite aligner les deux formes

il faut ensuite selectionner les deux formes et les regrouper en cliquant sur "Regrouper"

Nous allons ensuite ajouter des triangles afin de pouvoir poser la grille dessus puis cliquer sur regrouper

voici ce qu'on obtient :

Ajout d'une écriture sur une des faces : cliquer sur texte et écrire le texte voulu puis adapter la position désirée

Il faut ensuite percer

Étape n°2: la création de la grille

Servane Pellerin

Scéance 1

J'ai commencé par trouver une idée de modèle sur  : https://www.thingiverse.com/thing:312520

Pour la réaliser sur tinkercad, j'ai commencé par créer une forme en biseau, assez grande pour accueillir 2 savons.

J'ai ensuite rajouté des formes en biseau de manière complémentaire à ce biseau initial pour maintenir les savons dessus et en laissant l'eau ruisseler vers le bac de douche.

Afin de rajouter un élément 2D, je suis allée sur Inkscape et j'ai écrit "MY SOAP", j'ai modifié la police, l'espacement et j'ai mis le contour en chemin. Je l'ai ensuite enregistré en format .svg et je l'ai importé sur Tinkercad.

J'ai placé le texte à l'arrière de ma première forme en biseau, au milieu, peu mise en relief pour faciliter le nettoyage.

Scéance 2

Arduino : carte de développement
2 types de signaux :

Analogique: variations continues
Numériques/binaire : 1 ou 0

Loi d'Ohm : U = R*I
La résistance n'a pas de sens de branchement mais la Led oui, elle a une anode (côté +) et une cathode (côté -)

Test sur Tinkercad :

Test 1 avec les led : Okay
Test 2 avec le bouton : okay
Test 3 avec le buzzer : okay

Travaux pratique : avec Claire Huang, nous avons réalisé un circuit avec 2 led afin qu'elles s'allument à la suite, chacune pendant un cours laps de temps.
Voici le code :
#define LED_1 10
#define LED_2 9

int compteur = 0;

void setup()
{
 Serial.begin(9600);
 
 pinMode(LED_1, OUTPUT); // déclaration de la pin 10 comme sortie
 pinMode(LED_2, OUTPUT); // déclaration de la pin 9 comme sortie
}

void loop()
{
 Serial.print("Debut de la boucle ");
 Serial.println(compteur);
 
 digitalWrite(LED_1, HIGH);
 delay(1000); // ne rien faire pendant 1000ms
 digitalWrite(LED_1, LOW);
 delay(1000); // ne rien faire pendant 1000ms
 
 digitalWrite(LED_2, HIGH);
 delay(1000); // ne rien faire pendant 1000ms
 digitalWrite(LED_2, LOW);
 delay(1000); // ne rien faire pendant 1000ms
 
 compteur++; // incrémentation du compteur
}
Et voici une photographie de notre montage :
Mouna KHALIL

Projet – Semaine du 13 février 2023 : Réalisation d’un support pour savon
Introduction : 
L’objectif de ce premier projet est de réaliser un porte-savon. Ce dernier se compose de trois principaux éléments : 

Une grille sur laquelle se pose le savon
Un support qui contiendra l’eau issue du savon 
Un moyen d’évacuation permettant l’écoulement de cette eau 

Ces quelques lignes suivantes retracent mon processus créatif et technologique de la réalisation de mon porte-savon. Pour la modélisation 2D, j’ai utilisé le logiciel Tinkercad. Quant à celle en 3D, je me suis servie du logiciel Inkscape. 
NB : j’ai lancé l’impression de mon prototype jeudi matin et je verrai le résultat de cette impression après le rendu de cette trace écrite. 
I/ La grille 
Etape 1 : Croquis du prototype
J’ai laissé libre court à mon imagination pour réaliser la grille sur laquelle sera posé le savon et qui servira à l’écoulement de l’eau dont voici le modèle originel :

Figure 1 : Croquis de la grille
Etape 2 : Modélisation 2D de la grille
Afin de construire la grille, j’ai utilisé le logiciel Tinkercad.

Motif général

J’ai utilisé l’outil courbe de Bézier pour tracer le motif de base. Ce dernier sera donc reproduit plusieurs fois et en taille variable pour se conformer à mon croquis.
NB : Au début, je n’arrivais pas à tracer des lignes droites. De ce fait, j’ai dessiné un rectangle afin de me servir de ses côtés pour le faire. 

Figure 2 : motif de base

Motif complet 

J’ai donc réalisé le motif ci-gauche. J’ai utilisé l’outil courbe de Bézier pour dessiner chacun des éléments à gauche et je les ai dupliqués puis retournés verticalement pour avoir la version miroir. Pour chacun d’eux, j’ai dû créer de nouveaux nœuds afin d’affiner au mieux leur forme.

Figure 3 : V1 du motif

Arrondir le motif

Ensuite, je n’ai pas trouvé cela très esthétique car les bords n’étaient pas arrondis. Or, ma grille est circulaire. J’ai donc combiné l’utilisation d’un cercle ainsi qu’une opération booléenne pour y parvenir en suivant la démarche ci-dessous : 

J’ai tracé un cercle avec l’outil forme
Je l’ai positionné en arrière-plan grâce à la commande objets > descendre à l’arrière-plan
J’ai mis le motif à l’endroit souhaité en prenant garde à ce qu’il y ait une intersection avec le cercle
J’ai sélectionné les deux formes
J’ai rogné circulairement en utilisant la formule chemin > intersection
J'ai répété l'opération pour chaque forme.

     donne =>            

Figure 4 : Motif rogné circulairement

Motif final 

Après quelques modifications pour des raisons de design, j’ai donc obtenu le motif suivant. A savoir que j’ai rajouté un cercle autour du motif pour réellement obtenir une grille.

Figure 6 : Première importation 3D
=> Vous pouvez retrouver le fichier final en SVG en pièce jointe.

Seconde modélisation 3D

Les contours de la grille n'étaient pas lisses. Pour résoudre ce problème, j’ai donc dessiné un rond légèrement plus grand que la grille pour les recouvrir. Il fallait qu’il soit creux donc j’ai dessiné un cylindre de perçage légèrement plus petit que ce nouveau rond mais plus grand que la grille. Le problème était résolu !

Figure 7 : Importation 3D finale
II/ Le support 
Etape 1 : Le croquis
L’idée m’est venue de faire un porte savon en forme de sablier. D’une part, je trouve cela esthétique. D’autre part, je trouve qu’il est original de voir le sablier se remplir d’eau au fur et à mesure. Je me suis inspirée de l’image ci-à droite.
NB : Dans mon idéal, il faudrait que le sablier soit opaque. En effet, l’eau issue du savon pourrait être sale. De ce fait, cela pourrait être repoussant.
Figure 8 : Image inspiration sablier
Source : www.etsy.com 
Etape 2 : Modélisation 2D

Modélisation d’une demi-sphère

J’ai commencé par modéliser la demi-sphère qui constituera le haut de mon sablier. Cette dernière étant remplie, j’ai utilisé une autre demi-sphère de perçage légèrement plus petite afin de « vider » cette forme.

Figure 9 : Création de la forme
J’ai changé la couleur pour du transparent afin de voir l’écoulement de l’eau.

Figure 10 : Forme transparente

Modélisation du sablier en entier 

Pour modéliser le sablier en entier, j’ai modélisé une seconde demi-sphère pour la partie basse du sablier. J’ai donc également employé la méthode de perçage pour qu’elle soit creuse. Cependant, j’ai veillé à ce que cette sphère ait un fond plein. Afin de constituer le sablier, j’ai alors superposé et uni les deux formes en veillant à leur bon alignement. Cependant, afin d’obtenir un écoulement de l’eau, je devais creuser une cavité entre les deux parties du sablier. Ainsi, je me suis servie d’un cylindre de perçage (également préalablement aligné). J’ai tout regroupé pour ne former qu’un objet.

     

Figure 11 : Sablier finalisé

Réalisation du support permettant de soutenir la grille 

Pour manipuler plus facilement la grille, j’ai souhaité rajouter un support interne au sablier sur lequel elle serait posée. 

Tout d’abord, j’ai pensé à utiliser un tore mais ce dernier n’ayant pas la même forme de contour qu’une sphère, il y aurait eu des espaces vides.

Figure 12 : Tentative de grille avec une torre
Ainsi, j’ai préféré opter pour un anneau dont la forme serait plus adaptée. Après une union avec le sablier, j’ai donc obtenu le résultat suivant :

Figure 13 : Tentative de grille avec un anneau

La version finale du sablier

Figure 14 : Le sablier final
III/ L’assemblage 
Voici donc le résultat final du prototype :

Figure 15 : Le prototype final
Sablier : 
H = 158mm
L = 100 mm
l = 100m

Grille : 
H = 11mm
R = 90 mm
=>Vous pouvez retrouver les fichiers finaux en STL en pièce jointe.
IV/ L'impression 3D
Voici les paramétrages réalisés pour l'impression 3D :

=> Pour le sablier :

Hauteur de couche : 0,3
Coques : 3
Densité du remplissage : 10%
Motif de remplissage : rectiligne

=> Pour la grille :

Hauteur de couche : 0,1
Coques : 3
Densité du remplissage : 10%
Motif de remplissage : rectiligne

Hatice DAGLI

Inspiration
Pour créer mon porte savon, je me suis inspirée de ce modèle :

Modélisation 2D
Toutefois, je souhaitais faire quelque chose de plus minimaliste, je me suis donc lancée à dessiner une plante sur Inkscape :
Je commence par les branches avec des rectangles fins sans contours

J'incurve ensuite l'une des deux branches afin de donner cet aspect naturel via l'outil "objet en chemin", en choisissant le point qui fera une belle courbe arrondie :

                ---->            

Ensuite, j'ajoute les feuilles via l'ajout d'un élément rond que j'incurve de la même façon que la branche :

Je copie colle cette feuille plusieurs fois en plusieurs taille pour obtenir ma petite plante :

Je fais également sur Inkscape un ovale à la même dimension que ma plante afin de le mettre en 3D sur Thinkedcad (bien que ce ne fut pas l'idéal mais je détaille plus bas pourquoi).

Exportation sous .Stereolithography
Modélisation 3D

Sur Thinkercad, j'ai commencé par posé un cylindre que j'ai mis en ovale sur mon support de base vert.

J'ai ensuite ajouté 3 petits blocs de carré afin de faire tenir "ma grille" qui n'est autre que ma plante.

Problème : Ici, je me suis rendue compte que faire mon support de la même taille que ma plante n'était pas une bonne idée car ma plante n'aurais pas tenu sur le support sans aucun élément qui le tient en place. Il fallait donc réduire sa taille. Egalement, j'ai aussi appris qu'il était inutile que j'importe la base de ce support ovale depuis Inkscape car je pouvais le réaliser sur Thinkercad directement et plus facilement avec un élément ovale que j'aurais troué par perçage.
Enfin, j'ai décidé d'ajouter un espace par laquelle je pourrais verser l'eau qui s'accumulerais tout en ajoutant une touche décorative avec une écriture :

Que j'ai ensuite mis en perçage :

Et voici le plan du projet :

Exportation sous .SVG
Problème : Je me suis rendue compte sur IdeaMaker que les lettres o, a et p n'allaient peut-être pas bien sortir et que j'aurais du penser à ajouter un élément d'union pour faire tenir ces petits blocs.
Impression au FabLab SU
Pour pouvoir imprimer, il faut passer nos fichier en .GCODE via IdeaMaker
Attention : il faut bien mettre tous les éléments à plat (ma plante était en hauteur ici)

Nous réglons les paramètres et enregistrons le fichier pour enfin insérer la clé USB dans l'imprimante 3D.
Temps estimé : 11h d'impression
Résultat final

Remarques générales : Au fur et à mesure du projet, surtout lors de la modélisation 3D, je me suis rendue compte que ma grille plante n'était pas très pertinente car il était assez difficile de trouver un moyen simple de le faire tenir sur le support. En effet, j'aurais du réfléchir dès la modélisation 2D à comment je planifiais designer mon support.
(fichier gcode trop lourd pour mettre ici)
#include <LiquidCrystal.h> // inclusion de la librairie LCD
// initialise la librairie LCD avec les broches utiliséesLiquidCrystal lcd(1, 2, 4, 5, 6, 7); // déclare une variable LiquidCrystal appelée lcd avec mode 4 bits - RW non connectée (le plus simple!)
//déclaration des nouveaux caractères//création du caractère µbyte micro[8]={ B10001,  B10001,  B10001,  B10011,  B11101,  B10000,  B10000,  B10000};//création du caractère petit s de seconde en position haute pour tomber en face du µ lors de l'affichage.byte seconde[8]={  B01110,  B10000,  B01110,  B00001,  B01110,  B00000,  B00000,  B00000};
const int trigPin = 9; // déclare une variable à valeur constante de type const int (variable qui ne peut être modifiée, juste en lecture seule) appelée trigPin et valant 9 trig (Trigger = déclancheur) connectée à la broche numérique n° 9const int echoPin = 10;  // déclare une variable à valeur constante de type const int (variable qui ne peut être modifiée, juste en lecture seule) appelée echoPin et valant 10 trig echo (Echo = récepteur) connectée à la broche numérique n° 10long duration;//déclare une variable de type long appelée duration (Taille de 32bits).
// Instruction d'initialisation de la carte Arduino//**************** FONCTION SETUP = Code d'initialisation *****// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme
void setup() {
//Attribution des numéros des caractères    lcd.createChar(1, micro); // attribution d'un numéro au caractère créé    lcd.createChar(2, seconde); // attribution d'un numéro au caractère créé.

 

lcd.begin(16,2);  // initialise le LCD en mode 16 colonnes x 2 lignes
pinMode(trigPin, OUTPUT); //Configure la Broche spécifiée (ici la broche 9 digital) pour qu'elle se comporte en sortie avec OUTPUT.
pinMode(echoPin, INPUT); //Configure la Broche spécifiée (ici la broche 10 digital) pour qu'elle se comporte en entréeavec INPUT.
}
//*************** FONCTION LOOP = Boucle sans fin = coeur du programme *************// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension
void loop() {

digitalWrite(trigPin, LOW); /*Met un niveau logique LOW (BAS en anglais) sur une broche numérique 9. Si la broche a été configurée en SORTIE avec l'instruction pinMode(), sa tension est mise à la valeur correspondante : 5V  pour le niveau HAUT, 0V (masse) pour le niveau BAS.*/

delayMicroseconds(2);//La fonction delay() permet de mettre en pause le programme pendant un certain nombre de millisecondes. C'est une fonction bloquante. //La fonction delayMicroseconds() accepte un unique paramètre obligatoire qui correspond à la durée en microsecondes de la temporisation. Cette fonction accepte uniquement des nombres entiers.

digitalWrite(trigPin, HIGH);/*Met un niveau logique HIGH (HAUT en anglais) sur une broche numérique 9. Si la broche a été configurée en SORTIE avec l'instruction pinMode(), sa tension est mise à la valeur correspondante : 5V  pour le niveau HAUT, 0V (masse) pour le niveau BAS.*/

delayMicroseconds(10);//La fonction delay() permet de mettre en pause le programme pendant un certain nombre de millisecondes. C'est une fonction bloquante. //La fonction delayMicroseconds() accepte un unique paramètre obligatoire qui correspond à la durée en microsecondes de la temporisation. Cette fonction accepte uniquement des nombres entiers.

digitalWrite(trigPin, LOW);/*Met un niveau logique LOW (BAS en anglais) sur une broche numérique 9. Si la broche a été configurée en SORTIE avec l'instruction pinMode(), sa tension est mise à la valeur correspondante : 5V  pour le niveau HAUT, 0V (masse) pour le niveau BAS.*/

duration = pulseIn(echoPin, HIGH)/2;// affiche la durée du trajet entre l'emmetteur et l'objet .
lcd.clear();// efface l'écran et met le curseur en haut à gauchelcd.setCursor(0,0); // 1ère colonne - 1ère ligne - positionne le curseur à l'endroit voulu (colonne, ligne) (1ère=0 !)lcd.print("Temps: "); // affiche la chaîne texte - message de test (Ici Temps:)
lcd.setCursor(0,1);// 1ère colonne - 2ème ligne - positionne le curseur à l'endroit voulu (colonne, ligne) (1ère=0 !)lcd.print(duration);// affiche le calcul de la durée en µs entre l'émétteur et l'objetlcd.print(" "); // affiche la chaîne texte - message de test (Ici un espace)lcd.write(1); // affiche le caractère µ pour microlcd.write(2); // affiche le caractère s pour seconde
delay(5000);//La fonction delay() permet de mettre en pause le programme pendant un certain nombre de millisecondes. C'est une fonction bloquante. Ici 5 secondes pour permettre d'avoir une lecture stable du résultat.
}// fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin// Marveen LACOM

Projet Porte-Savon

Mon idée de projet était de faire un porte-savon dont la base est inclinée afin que l'eau puisse bien s'écouler à travers les évacuations.
De plus, je souhaitais y ajouter un système permettant de pouvoir accrocher le porte-savon à un mur.
Et enfin, je souhaitais que le support et la grille soient 2 pièces différentes, pour qu'il soit très simple de pouvoir nettoyer l'intérieur du porte-savon.

1) Création de la grille en 2D - Inkscape

J'ai d'abord recherché sur Internet un exemple de grille, que j'ai téléchargé en PNG.
Je l'ai ensuite importé sur Inkscape, et j'ai utilisé l'option "Vectoriser un objet matriciel".
Je souhaitais ensuite personnaliser cette grille, en y ajoutant un contour et des écritures dessus.
Voici le résultat obtenu :Cependant, j'ai repéré un premier problème : les traits de la grille étaient trop fins sur certains côtés, ce qui n'aurait pas permis à ma grille de tenir.
J'ai donc décidé d'augmenter l'épaisseur des traits composant la grille :

Et voici donc le résultat que j'ai obtenu en ajoutant l'écriture par dessus :

Le problème avec cette grille est apparu au moment de l'import du fichier SVG sur Tinkercad. Le résultat obtenu n'était pas du tout celui qui était attendu :

J'ai donc essayé d'ajouter une sorte de pancarte derrière l'écriture afin de remédier à ce problème.
Voici la grille que j'ai réalisée suite à cela :

Cependant, une fois encore, le résultat obtenu lors du passage sur Tinkercad n'était pas concluant du tout :

J'ai ensuite réessayé l'import avec le même fichier, mais cette fois-ci, j'ai obtenu ce résultat :

Le grillage ne s'est pas importé, contrairement à la pancarte.
Cependant, j'ai trouvé que cela pourrait être bien de n'utiliser que la pancarte, et de m'en servir de grille : l'eau pourrait couler à travers les lettres, ainsi, elle remplirait très bien ses fonctions, qui sont de laisser l'eau évacuer.

Voici donc les différentes étapes qui m'ont amenées à la grille que j'ai utilisée pour mon porte-savon.

2) Création du support en 3D - Tinkercad

En ce qui concerne le support de mon porte-savon, je l'ai réalisé en 3D sur Tinkercad.
Je suis parti sur la base d'une boîte, dans laquelle j'en ai ajouté une plus petite, que j'ai soustraite à la première.
Pour avoir les bonnes dimensions, j'ai mesuré un savon avec une règle, pour m'assurer que le savon rentrerait bien dans le porte-savon.
J'ai ensuite ajouté petits supports, qui me permettraient de pouvoir poser ma grille.
Voici le résultat :

Je voulais ensuite ajouter un support, qui pourrait me permettre d'accrocher le porte-savon à un mur, avec des ventouses par exemple.
Pour cela, j'ai ajouté une boîte à côté de mon support, à laquelle j'ai soustrait une autre boîte étant un peu plus petite.
Voici le résultat obtenu :

Ensuite, afin d'avoir une base inclinée, permettant aux gouttes de glisser vers une évacuation, j'ai ajouté un fond très fin servant de gouttière en ayant une très légère inclinaison, pour que les gouttes glissent jusqu'à la face avant. Et j'ai également fait un trou sur la face avant, pour que l'eau soit évacuée en dehors du porte-savon :

Je me suis ensuite dit que les gouttes qui couleraient sur le côté ne pourraient pas atteindre l'évacuation, car elle est trop centrale, donc j'ai voulu ajouter 2 nouvelles gouttières à gauche et à droite, qui permettraient de recentrer les gouttes dans l'axe :

Le résultat ne m'a pas satisfait, car il y avait des vides au niveau des jonctions entre les 2 petites gouttières et la grosse gouttière :

Cela aurait donc provoqué un blocage de l'eau étant passée par ces trous, et il n'aurait pas été possible d'enlever cette eau sans casser le porte-savon.
L'idée que j'ai donc eue a été de conserver seulement la grosse gouttières, mais d'ajouter 2 nouvelles évacuation à gauche et à droite :

De cette manière, l'eau pourra être évacuée du porte-savon, qu'elle soit à gauche, à droite, ou bien au milieu.

Voici donc le porte-savon final que j'ai créé :

3) Préparation à l'impression 3D - IdeaMaker

Une fois que mon fichier était prêt, je me suis mis à la préparation pour l'impression 3D.
Tout s'est bien passé, le seul souci à été au moment de la prévisualisation.
Voici ce que j'ai obtenu :

Comme on peut le voir sur la photo ci-dessus, 3 bandes apparaissaient sur la prévisualisation.
Avec l'aide de Clara Devanz et Stéphane Muller, nous avons trouvé que le problème venait de la trop faible inclinaison de ma gouttière, car l'imprimante ne pouvait pas reproduire une si petite inclinaison en une seule fois, elle devait faire des sortes d'étages.
Cependant, cela n'étant pas trop dérangeant, j'ai lancé l'impression 3D :

Et voici le début de mon porte-savon 3D :

Pièces jointes

J'ajoute en pièce jointes mes 2 fichiers : SVG, STL.
Je n'ai pas pu déposer le fichier QCODE, car sa taille était trop élevée pour pouvoir le déposer.

Projet Capteurs Arduino

Test Programme Blink

#define LED 4

void setup() {
 // put your setup code here, to run once:
 pinMode(LED, OUTPUT);
 Serial.begin(9600);

}

void loop() {
 // put your main code here, to run repeatedly:
 digitalWrite(LED, HIGH);
 delay(1000); // ne rien faire pendant 1000ms
 digitalWrite(LED, LOW);
 delay(1000);
}

#define LED 4

void setup() {

 // put your setup code here, to run once:

 pinMode(LED, OUTPUT);

 Serial.begin(9600);

}

void loop() {

 // put your main code here, to run repeatedly:

 digitalWrite(LED, HIGH);

 delay(1000); // ne rien faire pendant 1000ms

 digitalWrite(LED, LOW);

 delay(1000);
}

Test Capteur Distance

const int trigPin = 8;
const int echoPin = 11;
const int LED = 4;
// defines variables
long duration;
int distance;

void setup() {
 pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
 pinMode(echoPin, INPUT); // Sets the echoPin as an Input
 pinMode(LED, OUTPUT);
 Serial.begin(9600); // Starts the serial communication
}

void loop() {
 // Clears the trigPin
 digitalWrite(trigPin, LOW);
 delayMicroseconds(2);
 // Sets the trigPin on HIGH state for 10 micro seconds
 digitalWrite(trigPin, HIGH);
 delayMicroseconds(10);
 digitalWrite(trigPin, LOW);
 // Reads the echoPin, returns the sound wave travel time in microseconds
 duration = pulseIn(echoPin, HIGH);
 // Calculating the distance
 distance = duration * 0.034 / 2;
 // Prints the distance on the Serial Monitor
 Serial.print("Distance: ");
 Serial.println(distance);
 
 if (distance >= 250)
 {
 digitalWrite(LED, HIGH);
 }
 else
 {
 digitalWrite(LED, LOW);
 }
}

const int trigPin = 8;
const int echoPin = 11;
const int LED = 4;
// defines variables
long duration;
int distance;

void setup() {

 pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output

 pinMode(echoPin, INPUT); // Sets the echoPin as an Input

 pinMode(LED, OUTPUT);

 Serial.begin(9600); // Starts the serial communication
}

void loop() {

 // Clears the trigPin

 digitalWrite(trigPin, LOW);

 delayMicroseconds(2);

 // Sets the trigPin on HIGH state for 10 micro seconds

 digitalWrite(trigPin, HIGH);

 delayMicroseconds(10);

 digitalWrite(trigPin, LOW);

 // Reads the echoPin, returns the sound wave travel time in microseconds

 duration = pulseIn(echoPin, HIGH);

 // Calculating the distance

 distance = duration * 0.034 / 2;

 // Prints the distance on the Serial Monitor

 Serial.print("Distance: ");

 Serial.println(distance);

 if (distance >= 250)

 {

   digitalWrite(LED, HIGH);

 }

 else

 {

   digitalWrite(LED, LOW);

 }
}

Eloïse Chouraki

Etape 1 : création du socle
1. J'ai d'abord créé un bloc au dimension d'une boite de savon
longueur : 100 mm
largeur : 66 mm
hauteur : 36 mm

2. Pour faire le bac j'ai ensuite copier coller le même bloc en enlevant 15 mm aux dimensions de base. J'ai mis ce bloc en mode perçage puis je l'ai positionné au milieu du bloc précédent et j'ai regroupé les deux.

3. Pour faire l'évacuation, j'ai pris une forme paraboloïde que j'ai placée dans un des coins du bloc. J'ai ensuite mis la forme en mode perçage et j'ai regroupé le tout.

4. J'ai intégré une forme biseau pour faire les taquets permettant de soutenir la grille. J'ai dupliqué la forme et je l'ai mise sur les chaque côtés du bloc.

5. Finalement, j'ai enlevé les rebords de la deuxième forme pour avoir des bords carrés.

Etape 2 : Création de la grilles sur Inkscape
1. J'ai d'abord créé un rectangle au même dimension que mon socle.

2. J'ai créé une forme hexagonale à l'aide des formes proposées.

3. J'ai dupliqué cette forme en quatre pour les aligner.

4. J'ai groupé le tout afin de les dupliquer et être sure que les colonnes soient identiques.

5. J'ai placé les colonnes.

5. J'ai sélectionné une colonne que j'ai séparée pour pouvoir enlever un hexagone.

6. J'ai regroupé les trois hexagone puis je les ai dupliqués et placés sur la grille.

7. J'ai séparé tous les groupes pour pouvoir sélectionner le tout et faire une "exclusion"

Etape 3 : Assemblage du socle et de la grille
1. J'ai exporté ma grille en .svg puis je l'ai importé dans tinkercad.

2. J'ai ensuite rétréci l'épaisseur de la grille.

3. J'ai du réajuster la taille de la grille.

Etape 4 : Impression sur Ideamaker
1. J'ai exporté le tout en .STL et importé dans ideamaker.

2. J'ai modifié quelques paramètres.

3. Slice -> estimation du résultat d'impression

4. Aperçue de l'impression puis exportation du fichier sous forme de gcode.

Documents sources :
grille_porte_savon.svg
porte_savon.stl

Adrien de Lestapis

Porte Savon Pacman
Introduction :

Ce projet a débuté le 14 février 2023, étalé sur une semaine
L'idée est de réaliser un porte-savon avec un design original pour apprendre à utiliser logiciels de modélisation tels que Inkscape pour la Modélisation 2D, Tinkercad pour la Modélisation 3D et enfin IdeaMaker pour le Clipping.

Journal de bord
Etape 1 : Inspiration & Reflexion
Pour mon savon Pacman, il fallait explorer la meilleure option pour que le design soit le plus ergonomique possible. Il existe deux façon de se représenter Pacman dans l'imaginaire collectif, sa version 2D, originale, et sa version personnifié que l'on retrouve notamment dans le jeux Super Smash Bros. Ultimate.

Pacman 3D personnifié

Pacman 2D original

J'ai donc d'abord voulu partir sur sa version 2D pour la modélisation de mon porte savon, avec la création d'une sphere, et creuser à l'intérieur sa bouche pour laisser une place au savon (figure 1).

Figure 1 : Premier essai
Bien que le design semblait être le plus simple, il comprenait aussi plusieurs problème de taille :

Il n'y avait pas de place pour la grille.
Y prendre un savon avec les mains mouillés devient difficile.
Le manque de stabilité d'un porte-savon en boule, surtout si une parton du savon dépasse
Le côté plein et solide de la boule allait consommer plus plastique que nécessaire

Ce design a vite été abandonné et je suis parti sur son homologue 3D.

Etape 2 : Modelisation 3D de la structure

J'ai décidé de ne plus partir d'une boule mais deux 2 demi-sphère creuses, dont l'une allait servir de couvercle. J'ai donc pris une sphère aux dimensions 70x70, puis j'ai creusé avec avec une autre demi-sphère légèrement plus petite. Dans l'une des deux sphère, j'ai creusé un trou qui servira d'évacuation d'eau. Pour faire les jambes, jeux pris une forme cylindrique que je fait remonter jusqu'à la limite de ma demi-sphère. De cette manière, le haut des jambes va servir de support pour y mettre la grille.Pour rajouter un peu de stabilité à ma structure, je décide de rajouter les deux bottes rouges de notre boule jaune préférée. Je prends donc un cylindre et un demi-cylindre que je colle ensemble pour faire ma chaussure, puis je creuse dans chacune d'elle un trou légèrement plus grand que le diamètre de mes jambes.

Figure 2 : les éléments de mon Pacman

Etape 3 : Modelisation 2D de la grille

Pour la grille, je souhaite toujours garder l'identité de l'univers Pacman. c'est pourquoi je pense modéliser un niveau de jeu d'une partie en grille 2D.

Je prends donc un grille sur internet que je vectorise en 2D sur Adobe Illustrator (Inkscape n'étant pas compatible avec mon appareil). J'applique un masque décrêtage en d'un cercle pour rendre compatible la forme de la grille avec mon Pacman.
Voici le résultat obtenu :

Cependant, malgré tous mes efforts, l'export du modèle SVG dans Tinkercad semble ne pas fonctionner. Voici le résultat lorsque l'import SVG se fait dans TinkerCad.

N'ayant pas anticipé la difficulté de l'import SVG dans mon planning de travail, je n'ai pas réussi à trouver la solution dans le temps imparti avant la présentation finale.

Cependant je suis preneur de tout conseil pouvant me débloquer dans la réalisation du projet. DAHMANI Walid



Pour la réalisation de mon support pour savon je commence par réaliser une sphère sur le logiciel Thinkercad

J’utilise une seconde sphère de diametre inférieur afin d’évider la pièce principale

J’utilise une seconde forme afin de supprimer la partie supérieur de la sphére et révéler la partie évider de mon support

J’utilise enfin un cône afin de réaliser un trou à la base de la sphére afin de permettre à l’eau de s’écouler

J’utilise ensuite Inkscape afin de réaliser la plaque accueillera notre savon

Je désine les motifs que je souhaite sur ma surface et j’utilise la fonction soustraire afin d’imprimer mon motif

J’importe mon support sur TINKERCAD, et j’utilise une nouvelle sphére afin de créer une nouvelle surface plane. Celle-ci permettra de supporter le support à savon

Enfin j’utilise un cube afin d’aplanir la surface de contact de notre support à savon. L’objectif est de permettre à notre objet de rester stable.

Puis nous passons sur l'application Ideamaker afin de choisir les réglages de l'impression

Pour les réglages, je choisis le type d'imprimante correspondant à celle de l'openLab. Le type de matériau pour chaque extrudeure.
S'agisant d'une sphere avec une base fine, je choisis de réaliser une pièce avec une densité de 25%.

Je choisis également de réaliser une petite jupe afin de faciliter l'impression.

DIEVAL Cécile

Semaine 1 : projet porte-savon
Le but du projet est de réaliser un porte-savon en 3D.
Nous allons décomposer sa structure en deux parties :

- une grille en 2D via le logiciel Inkscape
Inkscape
- un contenant via le logiciel Tinkercad
Tinkercad
Nous allons imprimer ce porte-savon : 
- via le logiciel ideaMaker
ideaMaker
- via le logiciel Ultimaker Cura
Ultimaker Cura
Pour ma part, j'ai choisi de réaliser un porte-savon version Nintendo Mario Bros - Course aux pièces.

1.Modélisation 2D de la grille
a. Régler la longueur et la largeur de la feuille
Action : aller dans l'onglet fichier puis dans propriété du document 
Dimensions : 22 cm(longueur) X 18cm(largeur);et orientation=horizontal
b. Dessiner la forme de la grille
Action : prendre la forme rond

c. Dimensionner la forme

Action : Rx= 9cm et Ry= 7cm
d. Mettre des petit ronds pour construire la grille

Action : prendre la forme rond
e. Dimensionner le rond
Action : Rx = 2cm et Ry= 2cm
f. Créer la grille, en enlevant les petit ronds sur le rectangle
Action : utiliser la fonction chemin puis différence pour soustraire le motif

On aurait pu mettre un logo en plus, pour cela, il faut aller dans fichier puis importer une image; et également rajouter une épaisseur si besoin (cf.contour).
Fichier grille.svg ci-joint
2.Modélisation 3D du contenant
a. Importer le fichier sur Inkscape sur Tinkercad
Action : importer le fichier .svg
Dimensions : 90 mm (longueur) x 70 mm (largeur); et 10mm (épaisseur)
b. Créer la base du porte savon
Action : prendre la forme dé comme support
Dimensions : 90mm (longueur) x 74mm (largeur); et 40mm (épaisseur)

c. Juxtaposer le support et la grille

Action : s'aider de la commande plan

d. Créer le haut du tuyau pour la sortie d'eau (et pour que le savon ne se ramollisse pas)
Action : prendre la forme cylindre et aller dans ses paramètres afin de l'éditer au format perçage
Dimensions : 18mm x 17mm x 10mm (profondeur)
e. Créer la bas du tuyau pour la sortie d'eau (et pour que le savon ne se ramollisse pas)
Action : prendre la forme dé et aller dans ses paramètres afin de l'éditer au format perçage
Dimensions : 30mm (longueur) x 22mm (largeur) x 39mm (profondeur)
3.Impression 3D ultra haute qualité avec IdeaMaker
Toutes les impressions seront faites avec l'imprimante Raise 3D Pro2

4.Impression 3D rapide avec IdeaMaker

Fichier porte_savon.stl ci-joint

5.Impression 3D avec Ultimaker Cura avec l'imprimante Raise 3D Pro2 (simulation n°3)
Actions : 
- Importer le fichier porte_savon.stl

- Appuyer sur prepare
- Appuyer sur print

Fichier porte_savon.gcode non disponible car trop volumineux
6.Porte savon imprimé

Semaine 2 : projet montage électronique

Le but du projet est de réaliser un montage électronique avec une carte Arduino. Une carte Arduino est carte électronique équipée d'un micro-contrôleur.

1. Modélisation de circuit électrique
Matériels :

- Carte Arduino
Carte Arduino
- Logiciel Tinkercad
Tinkercad
Loi d'Ohm (Loi de Base en électronique) : U (tension aux bornes de la résistance) = R (valeur de la résistance) * I (intensité du courant qui circule à travers la résistance)
A. Blink programme

Il s'agit d'un programme qui sert à allumer une LED pendant une seconde, puis l'éteint pendant une seconde, de manière répétée.
Blink programme
Code associé :

#define LED 10 // connecte la LED sur la pin 10int compteur = 0;void setup(){Serial.begin(9600); // permet de dire que l'on va initier une communication entre l'ordinateur et le circuit à la vitesse 9600 pinMode(LED, OUTPUT); // déclaration de la pin 10 comme sortie}void loop(){Serial.print("Debut de la boucle ");Serial.println(compteur);digitalWrite(LED, HIGH); // Allume la LEDdelay(1000); // ne rien faire pendant 1000msdigitalWrite(LED, LOW);delay(1000); // ne rien faire pendant 1000mscompteur++; // incrémentation du compteur}

Bonus : on peut rajouter une deuxième LED
Code associé :

#define LEDA 10#define LEDB 12
int compteur = 0;
void setup(){  Serial.begin(9600);

pinMode(LEDA, OUTPUT); // déclaration de la pin 10 comme sortie pinMode(LEDB, OUTPUT); // déclaration de la pin 10 comme sortie}
void loop(){  Serial.print("Debut de la boucle ");  Serial.println(compteur);

 digitalWrite(LEDA, HIGH);  digitalWrite(LEDB, LOW);  delay(1000); // ne rien faire pendant 1000ms  digitalWrite(LEDA, LOW);  digitalWrite(LEDB, HIGH);  delay(1000); // ne rien faire pendant 1000ms

 compteur++; // incrémentation du compteur}

Image associé :

B. Bouton programme

Il s'agit d'un programme qui sert à allumer une LED via un bouton-poussoir.

Bouton programme
Code associé :

#define BTN 8#define LED 10
void setup(){  pinMode(BTN, INPUT_PULLUP);  pinMode(LED, OUTPUT); // déclaration de la pin 13 comme sortie

 Serial.begin(9600);}
void loop(){  if( digitalRead(BTN) == LOW )  {    Serial.println("Button pressed");    if( digitalRead(LED))

   {      digitalWrite(LED, LOW);      }      else      {    digitalWrite(LED, HIGH);      } }  delay(100);}

Image associé :

B. Buzzer programme

Il s'agit d'un programme qui sert à allumer le haut-parleur piézo via un bouton-poussoir.

Buzzer programme
Code associé :

#define POT A0#define BUZZ 9#define BTN 7
int etat = 0;
void setup(){  pinMode(POT, INPUT);  pinMode(BUZZ, OUTPUT);  pinMode (BTN, INPUT_PULLUP);

 Serial.begin(9600);}
void loop(){  int pot = analogRead(POT);  Serial.println(pot);

 int buzzfreq = map(pot, 0, 1023, 1000, 20000);

 if( digitalRead(BTN) == LOW )  {    if( etat == 1 )    {      noTone(BUZZ);      etat = 0;    }    else    {      tone(BUZZ, buzzfreq);      etat = 1;     }    }       

 

   delay(120);}

Image associé :

C. Capteur programme
Il s'agit d'un programme impliquant un capteur qui mesure la distance avec un LED qui s'allume si la distance est inférieur ou égale à 30m.

Capteur programme

/*  Ultrasonic Sensor HC-SR04 and Arduino Tutorial
*/// defines pins numbersconst int trigPin = 9;const int echoPin = 10;#define LED 7// defines variableslong duration;int distance;void setup() {  pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output  pinMode(echoPin, INPUT); // Sets the echoPin as an Input  pinMode(LED, OUTPUT);  Serial.begin(9600); // Starts the serial communication}void loop() {  // Clears the trigPin  digitalWrite(trigPin, LOW);  delayMicroseconds(2);  // Sets the trigPin on HIGH state for 10 micro seconds  digitalWrite(trigPin, HIGH);  delayMicroseconds(10);  digitalWrite(trigPin, LOW);  // Reads the echoPin, returns the sound wave travel time in microseconds  duration = pulseIn(echoPin, HIGH);  // Calculating the distance  distance = duration * 0.034 / 2;  // Prints the distance on the Serial Monitor  Serial.print("Distance: ");  Serial.println(distance);

 if (distance <= 30)  {   digitalWrite(LED, HIGH);  }  else  {   digitalWrite(LED,LOW);  }}

Image associé :

Réalisations associé :

Plus de 30m :

Moins ou égale à 30m :

Il existe également pleins d'autres programmes à réaliser avec la carte Arduino (Moteur, Capteur avec Action Moteur, Capteur de Temperature, ...)
Moteur programme
Temperature capteur programme

Nathacha

Nom du projet : Porte Savon Nathacha

Introduction :

Contexte + Objectifs : Dans le cadre de l'UE MU5MN045 - Outils technologiques de la conception innovante, nous allons créer un modèle 3D de porte-savon en deux parties (grille et contenant), le préparer pour l'impression et l'imprimer. Nous allons donc voir les concepts suivants : Modélisation 3D, Modélisation 2D, Impression 3D.
Date de début : Février

Date de fin estimée : Mars

Matériaux / Outils / Machines  : Nous allons utiliser plusieurs outils et une imprimante 3D.

Pour créer un ou plusieurs éléments 2D --> Inkscape

Pour la modélisation 3D --> Tinkercad

Pour slicer le modèle 3D --> Ideamaker

Construction / Journal de bord :
14/02/2023
Nous commençons par créer le grille du porte en 2D sur Inkscape.

1ère étape : Télécharger Inskcape via https://inkscape.org/release/inkscape-1.2.2/windows/64-bit/msi/?redirected=1
2éme étape : J'ai ouvert une nouveau document et défini les paramètres de 150x100mm pour la page.

Suite à cela, je crée un rectangle de 130x90mm en utilisant les paramètres sur le haut de la fenêtre L et H, afin que la taille soit assez grande pour contenir mes savons.

Grâce à l'onglet Objet > Fond et contour, je défini un nouveau fond et un style+couleur de contour.

Grâce à la fonctionnalité créer des polygones sur le côté gauche, je crée un design que je superpose pour obtenir une disposition qui me plaît.

Ensuite j'utilise la fonction aligner et distribuer pour que ce soit parfaitement aligner.

3ème étape : J'ajuste la taille du rectangle en fonction des polygones. Je télécharge le ficher en svg. J'ouvre mon compte Tinkercad > création conception 3D dans lequel j'importe mon design en ficher svg d'inkscape + un design choisi sur thingiverse pour le socle du porte savon --> https://www.thingiverse.com/thing:404028

4ème étape : En sélectionnant les deux objets et la fonctionnalité en haut a droite aligner je mets la grille à la bonne hauteur et bonne position par rapport au socle.

06/03/2023 
Semaine 2 - Création d'un circuit électronique

/*
 Ultrasonic Sensor HC-SR04 and Arduino Tutorial

 by Dejan Nedelkovski,
 www.HowToMechatronics.com

*/
// defines pins numbers

#define LED 8
const int trigPin = 9;
const int echoPin = 10;
// defines variables
long duration;
int distance;
void setup() {
 pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
 pinMode(echoPin, INPUT); // Sets the echoPin as an Input
 pinMode(LED, OUTPUT);
 Serial.begin(9600); // Starts the serial communication
}
void loop() {
 // Clears the trigPin
 digitalWrite(trigPin, LOW);
 delayMicroseconds(2);
 // Sets the trigPin on HIGH state for 10 micro seconds
 digitalWrite(trigPin, HIGH);
 delayMicroseconds(10);
 digitalWrite(trigPin, LOW);
 // Reads the echoPin, returns the sound wave travel time in microseconds
 duration = pulseIn(echoPin, HIGH);
 // Calculating the distance
 distance = duration * 0.034 / 2;
 // Prints the distance on the Serial Monitor
 Serial.print("Distance: ");
 Serial.println(distance);
 
 if( distance <=30 )
 {
 digitalWrite(LED, HIGH);
 }
 else
 {
 digitalWrite(LED, LOW);
 }
 
}

Marie DZAMBA

Informations

Marie DZAMBA
dzambamarie@gmail.com
Master Management de l'innovation / Fablab Sorbonne Université / MU5MN045
Du 13/02/2023 au 05/05/2023

Contexte
Dans le cadre de mon master 2 MI, j'ai suivi l'UE MU5MN045 qui avait pour but de nous sensibiliser aux outils technologiques de la conception innovante. Ce cours m'a permis de découvrir différents outils technologiques tels que les logiciels de modélisation 3D, les imprimantes 3D, les logiciels de simulation et les technologies de réalité virtuelle, entre autres. J'ai appris comment ces outils peuvent être utilisés pour faciliter le processus de conception et de prototypage de produits innovants. Cette documentation explore ma compréhension des avantages et des limites de ces outils, ainsi que les implications sociales de leur utilisation dans le domaine de la conception.
Objectif
Concevoir un objet innovant grâce aux différents ateliers et aux conférences suivies durant ces dernières semaines.

Journal de bord
Semaine du 13/02/2023
Objectif : Modélisation 2D/3D - Création d’un modèle 3D de porte savon en utilisant des logiciels de modélisation tels que Tinkercad
Durant cette semaine, j’ai essayé de me familiariser avec les logiciels de modélisation notamment avec des options telles que le perçage et le centrage.

Mon objectif était de réaliser un porte-savon avec un grillage en forme de toile d’araignée. Malheureusement étant malade lors des dernières séance, je n’ai pas pu aller au bout de mon projet.

Toutefois, voici les étapes que j’ai retenue lors des échanges avec Clara et Stephane afin de réussir au mieux la conception du modèle 3D de mon porte-savon :

Identifier les bonnes dimensions afin de concevoir un modèle précis

Choisir le logiciel de modélisation le plus adapté pour l’objet

Une fois le logiciel sélectionné, il faut commencer à créer la forme de la base et bien ajuster les angles pour anticiper l’impression
Ajouter des détails comme des rainures pour permettre l’écoulement de l’eau, des trous pour la ventilation, des motifs etc. Il faut également jouer avec les différents outils de modélisation 3D tels que l’extrusion, la rotation, le biseau, etc. pour ajouter les détails.
Un fois le modèle terminer, il est important de vérifier la faisabilité de l’impression en s’assurant que les bords du porte-savon soient assez épais, ou bien que la base soit assez solide pour maintenir l’objet pendant l’impression.

A ce sujet, la plus grosse difficulté pour moi était de concevoir les parties flottantes de la base qui allaient soutenir la grille en forme de toile d’araignée. Je n’ai pas réussi à les faire fusionner avec les rebords du porte-savon. Du coup, à l’impression je pense qu’elles se seraient détachées.

Dernière étape, exporter le modèle au format STL pour être utilisé avec l'imprimante 3D

(photo imprimantes fablab)
Semaine du 06/03/2023
Objectif : Introduction à l'électronique numérique*
Lors de cette semaine, nous avons revu les bases de l'électronique en utilisant des composants électroniques tels que des capteurs, des résistances, des LED et des boutons. Nous avons également appris à utiliser les logiciels associés pour programmer ces composants afin de créer des projets électroniques interactifs (doc 1, 2 et 3).
Plus spécifiquement, Stéphane nous a montré comment coder des instructions pour la carte Arduino en utilisant un langage de programmation (doc 5).

Nous avons utilisé l’outil simulation de Tinkercad pour simuler des petits projets interactifs avant de les mettre en oeuvre sur une carte Arduino réelle (doc 4).
Nous avons aussi connecté des composants électroniques à la carte Arduino en utilisant des boutons ou des capteurs de mouvement.
A l’issu des ateliers, nous avions toutes les cartes en main pour explorer différentes façons d'utiliser ces outils pour créer des projets électroniques originaux et utiles (A suivre : EL DISTRIBUTO).

Doc 1:

Doc 2 :

Doc 3:

Doc 4 :

Doc 5 :

*Absente lors de l'atelier sur la découpe laser, rattrapage avec mon groupe pour le projet final

Semaine du 03/04/2023
Conférence animée par Adrien ROUET, fondateur de ESQUISSE 3D.

Esquisse 3D a pour vocation d'accompagner des projets hardware électronique et mécanique du prototypage à l'industrialisation.
Lors de la conférence, Adrien nous a expliqué comment il accompagne les entrepreneurs dans leur processus de création. Il nous a donné quelques pistes/conseils pour qu'à notre tour nous puissions nous lancer si l'expérience nous tente.

Voici mes notes avec les points les plus importants que j'ai retenu :

Avant de concevoir et de développer un produit, il est important de comprendre les besoins et les attentes des utilisateurs pour pouvoir créer un produit qui répondra le mieux à leurs besoins
Créer un prototype fonctionnel pour valider le concept de base et les hypothèses de conception. Adrien a d’ailleurs mentionné l’utilisation d’outils de conception assistée pour créer des modèles 3D du produit avant de réaliser des impressions 3D pour créer des prototypes physiques
Bien tester le prototype pour identifier les problèmes et les points à améliorer
Utiliser les commentaires des utilisateurs pour améliorer le produit et recommencer jusqu'à ce que le résultat soit assez satisfaisant (pas besoin d’avoir un produit parfait à ce stade)
Une fois le prototype prêt, il faut planifier la production en série (il est important de trouver des fournisseurs de confiance)

Le produit doit ensuite être testé et certifié avant d'être commercialisé pour garantir qu'il répond aux normes et réglementations applicables (étape importante car certaines certifications sont difficiles à avoir)
Trouver un partenaire de fabrication pour aider à industrialiser le produit
Élaborer une stratégie de marketing pour promouvoir le produit auprès du public cible

Conclusion
En conclusion, les différents ateliers ont été très bénéfiques pour moi, car j'ai pu acquérir de nouvelles compétences en conception et prototypage. J'ai enfin pu apprendre  à utiliser des technologies telles que l'impression 3D et la découpe laser lors de la conception de El Distributo.
J'ai fortement apprécié les conseils d'Adrien Rouet. Ce dernier m'a aidé à comprendre les différentes étapes de la création de produits d'un point de vue plus technologique, de la conception au prototypage en passant par la production en série. J'ai bien pris notes des conseils sur les aspects réglementaires et les normes de qualité à respecter pour la mise sur le marché de produits électroniques.
Dans l'ensemble, ces ateliers m'ont permis de mieux comprendre les enjeux de la création de projets hardware et de développer des compétences pratiques.
Je tiens à remercier Clara et Stéphane qui ont pris le temps de nous orienter et de nous conseiller au mieux durant toute l'UE. UE COREPS



Conception d'un fumoir à levure

Conception d'un fumoir à levure

Concevoir et réaliser un projet scientifique. Telle est la consigne qui nous a été imposée dans le cadre de l'enseignement médecine/science.

Nom du projet : Fumoir à levure (nom commercial de cette invention de génie encore à élaborer)
Coordonnées : 
BEN FREDJ Mohamed-Fehmi, mf.benfredj@gmail.com DFGSM3 Cursus Médecine/Science Projet M1)
BERGONZOLI Élise Elisebergonzoli0305@gmail.com DFGSM3 Cursus Médecine/Science Projet M1)

Quelques contraintes :

- Le modèle expérimental : Saccharomyces cerevisiae, la levure de boulanger.
- L'étude du stress oxydant.
La cigarette classique est connue dans la bibliographie comme étant nocive pour nos cellules via notamment le stress oxydant induit dans les cellules exposées à la fumée et aux nombreux mutagènes contenue dans cette dernière.
Notre étude étudiera quant à elle les effets de la cigarette électronique sur le stress induit chez les levures. Plus précisément nous cherchons à mettre en évidence l'hypothétique nocivité de la PUFF ou e-cigarette jetable.
Notre questionnement fait suite à un constat édifiant : les constructeurs de ces PUFFs visent un public de plus en plus jeune et même mineur. Des collégiens, des lycéens s'emparent de cette nouvelle drogue au packaging conçu pour leurs plaire. Le concept est simple : des cigarettes électroniques peu chères, vendues partout, aux goûts et saveurs fruitées ou de bonbons, avec ou sans nicotine. L'inquiétude : l'entrée dans le tabagisme des plus jeunes via le passage du sans nicotine aux produits nicotinés. Mais aussi ! la légende que la cigarette électronique ne serait que "de l'eau et du sucre" et que la fumée en tant que telle (sans nicotine) ne serait pas nocive se répand...comme une trainée de poudre.
L'objectif pour nous dans un premier temps est donc de créer un dispositif permettant au levures, jusqu'a ce que l'évolution les dotes de bouches et de poumons, de fumer !
L'idée est de mettre sur pied un poumon géant, tirant de manière autonome sur les PUFFs. Ce poumon serait rempli de nos levures. Grâce à un système de pompe à vides controlées par Arduino et une bonne isolation nous imposerons un rythme respiratoire suffisamment fort pour tirer sur les cigarettes, sans griller les résistances et évacuant la fumée. Ce poumon sera compartimenté en plusieurs "fumoirs" pour pouvoir tester plusieurs conditions expérimentales en même tempsImplication de la protéine Rif1 dans la réponse à différents stress sur les télomères chez S.cerevisiae

ESTEVES AlexisIDIR RyaneZHOU Hélène helene2009@live.cn
Lorsqu'une levure est exposée à différents stress, les télomères sont affectés. Il a été démontré par le passé que la caféine et les hautes températures raccourcissaient les télomères et à l'inverse que les alcools (éthanol, isopropanol, méthanol) rallongeaient les télomères. Dans cette étude nous cherchons à démontrer que la réponse à ces différents stress passe par la voie du complexe Rap1-Rif1-Rif2. Pour cela nous nous intéressons aux phénotypes des levures qui découlent de télomères courts ou longs :

La vitesse de croissance et le temps de doublement
Observation au microscope
Cytométrie en flux

Conditions étudiées :

WT (BY4741), sans traitement

tlc1 delta, sans traitement

tsa1 delta, sans traitement
WT, caféine 8mM
WT, isopropanol 5%

20/03/2023
Préparation de milieux de culture complet YPD liquide (500 mL) et solide (250 mL)
21/03/2023

 Mesure de turbidité des précultures pour ensemencement

 Suivi de la croissance par mesure de turbiditéL'oxydation des levures par H2O2

Cardon Laura, Calingarayar Lydie, Martin Fanny,
Projet M1 BMC COREPS :
Etude de l'effet de la quercétine sur des levures délétées en catalase dans le cadre de l'acatalasémie.
10/03
Sur des levures WT et délétés en catalases, on induit un stress avec de l'H2O2 à des concentrations différentes et on établit le taux de survie des deux souches. Pour ce faire, on effectue une gamme de concentration de H2O2 et on expose nos levures à ces différentes concentrations. Pour la suite des expériences on utilisera la concentration d'H2O2 qui donnera un taux de survie de 50% des levures pour les deux souches.

Produits : Quercetin hydrate >95% (Aldrich Chemistry)
Étude du stress oxydatif quercétine dans des cas d'acatalésémie

Informations

Nom du projet : étude du stress oxydant quercétine dans des cas d'acatalésémie
Coordonnées : Fanny MARTIN fanny.martin.2.@etu.sorbonne-universite.fr ; Lydie CALINGARAYAR lydie.martin@etu.sobonne-universite.fr ; Laura CARDON laura.cardon@etu.sorbonne-universite.fr

Contexte

Objectifs
 Hypothèse : quercétine reduit le stress oxydant dans des cas d'acatalésémie
Protocole

Solubiliser le quercétine

Mesurer la densité optique avec le spectrophotomètre
Tracer la courbe de croissance
Réaliser le comptage en gouttes

Machines utilisées
Spectrophotomètre

Journal de bord 
17/03 Spectrophotométrie et Comptage en gouttesÉtude du stress oxydatif sur la levure en présence de saccharine et de néohespéridine

Informations

Nom du projet : étude du stress oxydant sur la levure en présence de saccharine et de néohespéridine
Coordonnées : 
christine.lin.1@etu.sorbonne-universite.fr

caroline.sreng@etu.sorbonne-universite.fr

Objectifs : vérifier les hypothèses
Hypothèse 1 : Saccharine induit le stress oxydant 
Hypothèse 2 : Néohespéridine diminue le stress oxydant
Protocole

Comptage en gouttes

Machines utilisées
Spectrophotomètre

Journal de bord 
17/03 Spectrophotométrie et Comptage en gouttes
Étude du stress oxydatif sur la levure en présence de resveratrol et de EGCG

Nom : MANSOUR Elyr elyn.rouanet@gmail.com

MALANDA Chloé chloe.omalanda@gmail.com 
Projet :  Alzheimer, Rôle du resveratrol et de EGCG sur l'accumulation des peptides A bêta 42.
Hypothèse : Le resveratrol et l'EGCG ont un rôle curatif et préventif sur la formation des agrégats de peptides A bêta 42 
Recyclage du péroxyrédoxine par thyorédoxine,étude sur S.cerevisiae

Réalisation: Martins Claudia et Galappaththi DulanjiEffet du stress oxydatif sur le facteur de transcription YAP1,étude sur S.cerevisiae

Réalisation: SONG Haibing et CHADEAU LaetitiaUE MU5BEB41 - EPET

Environnement et EcoInnovations Végétales (M2)

Micropousses sur gel d’agar - Champerché

Projet réalisé en Co-Working avec Champerché réalisé par : Margot Kandel, Lou Gimeno, Aurélie Saussais
Recherche de substrat de culture de micropousseCulture en aéroponie sur tours - Cueillette Urbaine

Projet réalisé en Co-Working avec Cueillette Urbaine réalisé par : Julien Page, Olivia Renard

Impact de différentes concentrations initiales en solutions nutritives sur la croissance de Lactuca sativa L. en tours aéroponiques
Marqueurs de stress hydrique chez 2 variétés de laitues - NovaGenetic

Projet réalisé en Co-Working avec NovaGenetic par : Clarisse Giner, Noémie PiivaiEssais d'une molécule florescente sur différentes espèces - Aglaé

Projet réalisé en Co-Working avec Aglaé réalisé par : Marion Lusin, Marion Maceiras, Caroline SansonEPU-C6-DEE

Engagement étudiant ROB3.

Distributeur de protections hygiéniques

Viven Mael / Brietzke Louis

Responsable : Myriam Comte
Au court de notre année de ROB3 nous nous devons de faire un engagement étudiant. Ainsi nous avons choisi d'intégrer l'association HeforShe qui nous aidé à trouver l'idée du distributeur. Le distributeur a pour but de pallier à la précarité hygiénique des étudiantes. Ce genre de borne existe déjà on a donc opté pour cette forme :

Après étude nous avons réalisé que la motorisation n'était pas pertinente au vu du fait que nous souhaitons que cette borne soit en accès libre. Nous avons donc opté pour une solution plus basique avec une simple évaluation des stocks qui permet de connaitre à tout moment les quantités restantes. Pour ce faire nous avons coder, dans une Raspberry, un programme qui réceptionne les données des quantités et qui les envoie par mail à une boite mail qui y est dédié.
Notre modèle comportera 6 compartiments qui comprendrons sur notre premier prototype 3 compartiments serviette et 3 compartiments tampon. Nous avons pour objectif (cela va dépendre des fournisseurs que nous obtenons) d'avoir 4 compartiments serviette et 2 compartiments tampon. Afin d'être conforme à notre sondage qui indique une tendance (dans les distributeurs existant) à manquer de serviettes plus que de tampons.
Pour la construction de notre premier prototype nous avons analysé les différentes tolérances des machines de découpe afin d'adapter nos modèles. Malheureusement nous n'avons pas pris en compte les matériaux à disposition nous avons donc la nécessité de réadapter nos modèles. Finalement nous avons choisi d'utiliser la découpe laser et des plaques de 6mm de peuplier pour créer notre borne.
Le modèle d'origine
Le modèle de découpe
Le résultat
Nous nous sommes ensuite penchés sur le câblage de la boîte. Comme précisé précédemment nous utilisons une Raspberry ainsi que de nombreux câbles et capteurs à ultrason HC-SR04.Machine à poids

Informations

Le Floch Mael / Sauvenay Antoine
Mael.Le_Floch@etu.sorbonne-universite.fr / Antoine.Sauvenay@etu.sorbonne-universite.fr
CIA pole escape game
débuter le 10 octobre 2022, fin prévu le 21 avril 2023

Contexte
Lors de notre année de ROB3, nous devons réaliser un projet étudiant, le nôtre consiste en la création d'un Escape game au sein de la collection des minéraux, ce dernier est articulé en 5 énigmes principales dont l'une correspond à une boîte à poids qu'Antoine a modélisé sur Solidworks.
Objectifs
Le principe de la machine à poids est le suivant: dans un boîtier est contenu plusieurs balances, ces balances ont toutes un de leurs cotés sortant du boitier et étant accessible par l'utilisateur, l'autre partie est en relation avec un tube dans lequel quelque chose peut être stocké, lors que toutes les balances sont placées à l'équilibre, il est possible à l'aide d'un poussoir de faire sortir l'objet stocké. Ce système s'apparente à un gros cadenas actionnés par des poids. Lorsque le système sera entièrement terminé, il ressemblera à ceci:
(problème de téléchargement de la photo, le problème sera résolu au plus vite)

Matériel

plastique de type PLA
bois

Machines utilisées
imprimante 3d
découpeuse
Construction
Étape 1
modélisation de l'ensemble des pièces du système
Étape 2
réalisation de toutes les pièces qui ne peuvent être faite autrement que avec des machines
Étape 3
Assemblage de l'ensemble du système: il faudra débuter par les supports, installer les différents guidage, assembler les balances, mettre les pièces de maintient en position, puis mettre le capot.
Journal de bord
10/2022
Début de la modélisation du système, il a été nécessaire de penser à toutes les pièces qui pourrait être remplacer par des pièces de récupération, afin d'économiser au maximum les matériaux.
13/01/2023
Impression du premier lot de pièce, en l'occurence les supports de balance, ayant consommer environ 130g de PLA et 20h de temps machine chacun.

17/02/2023
Impression des supports pour le guidage des pierres, ils ont consommé environ 70g de PLA et une dizaine d'heure de temps machine chacun.

23/03/2023
impression des guidage des pierres, ils ont consommé environ 14g de PLA et 4 heures de temps machine chacun.Mesure de la portance de différents profils et matières d’hydrofoil

Coordonnées

Benjamin Gauthey (benjamingauthey@yahoo.fr), élève ingénieur à Polytec Sorbonne
Alexandre Malet (alexandre.malet@etu.sorbonne-universite.fr), élève ingénieur à Polytec Sorbonne

Introduction

Date de début: 24 février 2023
Date de fin estimée: 28 mai 2023
Objectifs: Créer différents profil d'hydrofoil ainsi qu'un dispositif expérimental pour mesurer la portance de ces derniers

Contexte: Ce projet s’inscrit dans le cadre de l’UE « Engagement étudiant »

Outils et Machines

Imprimante 3D Raised 3D pro(FabLab Sorbonne Université)
Logiciel de design 3D : Blender
Gouttière avec un courant d’eau régulé (Labo de Mécanique des Fluides)
Dispositif expérimental pour les mesures (à détailler)
Logiciel Blender (pour concevoir les profils d’hydrofoil)
Découpeuse laser
Perceuse colonne

Perceuse / Scie à métaux / Touret à poncé

Matériaux

Filament PLA (FabLab Sorbonne Université)
Plaque PLA 3x500x300mm
Boulon et ecrous M3/M4
Tige filetée acier M4
Rails de guidage aluminium
Ressorts

Construction de l'hydrofoil

Nous avons utilisé le logiciel Blender pour concevoir les profils d’hydrofoil en nous inspirant de modèles existants. Nous avons choisi des formes simples et symétriques pour faciliter l’impression 3D. Nous avons exporté les fichiers au format STL pour les envoyer à l’imprimante 3D.
Nous avons imprimé les hydrofoils en PLA avec l’imprimante 3D Raised 3D pro du FabLab.
Nous avons commencé à fabriquer un dispositif expérimental pour mesurer la portance des hydrofoils. Le dispositif est placé dans la gouttière avec un courant d’eau régulé par une vanne.
Voici les paramètres d'impression que nous allons testé d'utilisé:

Paramètres généraux Hauteur de la couche (Layer Height) : Réglez cette valeur sur une valeur inférieure à la taille de la buse de votre imprimante 3D, généralement entre 0,1 mm et 0,3 mm pour une buse standard de 0,4 mm. Plus la hauteur de la couche est faible, plus les détails de l'objet imprimé seront précis et moins il y aura d'aspérité sur la surface.
Vitesse d'impression (Print Speed) : Réduisez la vitesse d'impression pour une meilleure qualité d'impression. Vous pouvez essayer de régler la vitesse d'impression à environ 40-60 mm/s.
Température d'extrusion (Extrusion Temperature) : Réglez la température d'extrusion selon le matériau que vous utilisez. Si vous utilisez un PLA standard, vous pouvez régler la température entre 190°C et 220°C.
Densité de remplissage (Infill Density) : Réglez la densité de remplissage pour réduire le risque de défauts d'impression. Vous pouvez essayer de régler la densité de remplissage à environ 20-30%. Support (Support) : Si votre modèle nécessite un support pour être imprimé, sélectionnez l'option "Support Everywhere" pour éviter les défauts d'impression.
Plus de précision sur les vitesses Vitesse de déplacement (Travel Speed) : Il s'agit de la vitesse à laquelle l'extrudeur se déplace lorsqu'il ne dépose pas de filament, par exemple lorsqu'il se déplace d'un endroit à un autre de l'imprimante. Vous pouvez régler cette vitesse à une valeur plus élevée, par exemple 80-100 mm/s.
 Vitesse de la première couche (First Layer Speed) : La première couche est la plus importante, car elle détermine la stabilité de l'impression. Il est recommandé de régler la vitesse de la première couche à une valeur inférieure à la vitesse d'impression pour les couches suivantes. Vous pouvez essayer de régler cette vitesse à environ 20-30 mm/s.
Vitesse de la coque (Outer Wall Speed) : La coque est la paroi extérieure de l'objet imprimé. Pour obtenir une surface lisse et régulière, il est recommandé de régler la vitesse de la coque à une valeur inférieure à la vitesse d'impression pour les couches intérieures. Vous pouvez essayer de régler cette vitesse à environ 30-40 mm/s.
Vitesse de remplissage (Infill Speed) : La vitesse de remplissage correspond à la vitesse à laquelle le filament est déposé pour remplir l'intérieur de l'objet. Vous pouvez régler cette vitesse à une valeur plus élevée que la vitesse de la coque, par exemple à environ 50-60 mm/s. Densité et flottaison La densité de l'objet, associée à la densité de l'eau, détermine si l'objet flottera ou coulera. Pour qu'un objet ne flotte pas dans l'eau, il doit être plus dense que l'eau. La densité de l'eau est d'environ 1 g/cm³ à température ambiante. Si votre objet a une densité de 1,25 g/cm³, alors pour qu'il ne flotte pas dans l'eau, il doit être rempli à au moins 80% de sa capacité totale.

Voici comment vous pouvez calculer cela : Calculez le volume total de votre objet en multipliant sa longueur, sa largeur et sa hauteur. Multipliez ce volume total par la densité de votre matériau pour obtenir la masse totale de l'objet. Divisez la masse totale de l'objet par le volume total pour obtenir la densité réelle de l'objet. Pour déterminer le pourcentage de remplissage nécessaire pour que l'objet ne flotte pas, divisez la densité réelle de l'objet par la densité de l'eau (1 g/cm³) et multipliez le résultat par 100. Par exemple, si votre objet a une longueur de 10 cm, une largeur de 5 cm et une hauteur de 2 cm, son volume total serait de 100 cm³. Si vous utilisez un matériau ayant une densité de 1,25 g/cm³, la masse totale de l'objet serait de 125 g. En divisant 125 g par 100 cm³, on obtient une densité réelle de 1,25 g/cm³. Pour que l'objet ne flotte pas dans l'eau, sa densité réelle doit être supérieure à 1 g/cm³. Ainsi, pour que l'objet ne flotte pas, il doit être rempli à au moins 80% de sa capacité totale. Il est important de noter que la densité réelle de l'objet peut varier en fonction du pourcentage de remplissage et de la structure interne de l'objet, donc il est recommandé de faire des tests pour déterminer le pourcentage de remplissage optimal pour votre objet.

Journal de bord

12 janvier 2023: Début du projet. Recherche bibliographique sur les hydrofoils et leurs applications. Choix du sujet et des objectifs.

16 février 2023: Conception des profils d'hydrofoil avec Blender. Exportation des fichiers STL.

25 février 2023: Première tentative d'impression 3D des hydrofoils. Échec à cause d'un bug de la machine en cours de route.

29 février 2023: Deuxième tentative d'impression 3D des hydrofoils. Réussite, mais résultat insatisfaisant à cause des aspérités sur le dessus et le dessous des foils.

2 mars 2023: Analyse des problèmes d'aspérités et recherche de solutions : après évaluation, nous décidons d'imprimer les hydrofoils sur la tranche afin de bénéficier d'une surface plus lisse, réduisant ainsi les aspérités.

3 mars 2023: Révision du design des hydrofoils sur Blender pour éliminer les aspérités et réduire le poids. Nous constatons que le poids actuel pourrait ne pas permettre aux hydrofoils de générer suffisamment de poussée pour se soulever. Par conséquent, nous apportons des modifications pour optimiser le design et réduire le poids.

9 mars 2023: Troisième tentative d'impression 3D des hydrofoils en utilisant le nouveau design et de nouveaux paramètres d'impression, tenant compte des modifications apportées pour éliminer les aspérités et réduire le poids.

10 mars 2023: Hydrofoils optimisés, sans aspérités et avec une densité et un poids idéaux. Cependant, étant donné que les hydrofoils ne sont pas pleins (présence d'une cavité vide à l'intérieur), il est important de s'assurer qu'ils ne se remplissent pas d'eau. Par conséquent, nous décidons d'appliquer plusieurs couches de solution hydrophobe sur leur surface pour éviter l'accumulation d'eau.

14 mars 2023: Conception théorique (plan/maquette) du dispositif expérimental pour mesurer la portance des hydrofoils dans la gouttière à courant d'eau régulé, située dans le Laboratoire de Mécanique des Fluides.

21 mars 2023: Problème ! Les hydrofoils sont trop larges, ce qui nous empêche d'insérer le dispositif de portance dans la gouttière. Nous devons donc revoir le design des hydrofoils pour les rendre plus étroits tout en garantissant une portance suffisante.

23 mars 2023: Conception d'un nouveau design d'hydrofoil sur Blender, avec des dimensions réduites en termes de largeur, mais plus longues pour assurer une portance adéquate dans la gouttière expérimentale.

(Dimension précédente)

(Nouvelles dimensions)

28 mars 2023: Problème ! Nous avions prévu de percer les hydrofoils à l'aide de la perceuse à colonne pour faire passer une tige filetée à l'intérieur et ancrer cette tige dans le dispositif de mesure. Cependant, nous constatons que nous ne disposons pas d'une mèche assez longue pour atteindre le centre des hydrofoils. Nous devons donc effectuer une modification du design des hydrofoils sur Blender en ajoutant un trou au centre pour faire passer la tige filetée.

4 avril 2023: Pour mesurer la portance de nos hydrofoils, nous aurons besoin de ressorts. L'objectif est de mesurer l'extension des ressorts pour déterminer la force qui leur est appliquée, à l'aide de la constante de raideur. Aujourd'hui, nous avons conçu un système de mesure pour cette constante.

6 avril 2023: Pour la fabrication du système de mesure de la constante de raideur et sa mesure à l'aide du dispositif conçu, nous avons procédé comme suit : nous avons fixé une bouteille d'eau à chaque ressort et progressivement ajouté du poids (de l'eau) à chaque mesure, ce qui a généré des paliers de poids différents. À chaque palier, nous avons enregistré l'étirement du ressort. Ces mesures ont ensuite été représentées sur un graphique, formant une droite dont le coefficient directeur correspond à notre constante de raideur, k.
Il convient de noter que nous avons testé plusieurs ressorts dans le processus, car nous recherchions une constante de raideur faible en raison de la faible force de portance de l'hydrofoil. En effet, si la valeur de k avait été trop élevée, il aurait été plus difficile de mesurer l'étirement de manière précise.

11 avril 2023: Fabrication du système de mesure de la portance externe (schéma) comprenant deux rails de guidage connectés par trois tiges filetées maintenues en place par six boulons et rondelles. Montage et vérification de la stabilité et de la robustesse du système.

13 avril 2023: Tentative de fabrication du système de maintien de l'hydrofoil (schéma). Cette partie est mobile et se déplace le long des rails de guidage. Elle est composée de deux lamelles de plastique LPA de 3 mm découpées au laser. Cependant, nous avons constaté une erreur de mesure dans les patrons, ce qui nécessite des ajustements.

14 avril 2023: Rectification des mesures du système de maintien de l'hydrofoil. Les lamelles sont redécoupées au laser selon les nouvelles dimensions précises.

18 avril 2023: Assemblage final du système de maintien de l'hydrofoil et du système de mesure de la portance externe. Vérification de leur fonctionnement conjoint et de leur compatibilité.

2 mai 2023: Premier test de portance dans la gouttière expérimentale. Cependant, nous rencontrons des difficultés avec le système de maintien de l'hydrofoil qui ne coulisse pas correctement sur les rails de guidage. Les frottements sont trop importants, ce qui nous empêche de mesurer l'extension du ressort de manière précise.

4 mai 2023: Modification et lubrification des rails de guidage pour réduire les frottements. Suite à ces ajustements, le système de maintien de l'hydrofoil coulisse beaucoup plus facilement, permettant enfin de prendre des mesures précises.

5 mai 2023: Prise de mesures avec quatre profils d'hydrofoil différents, de densités différentes, étanches ou non, et en variant les paramètres de débit et de hauteur dans la gouttière expérimentale. Collecte des données sur la portance obtenue pour chaque configuration.

11 mai 2023: Finalisation du rapport final du projet, incluant les résultats expérimentaux, les conclusions et les
recommandations. Préparation de la présentation du projet, résumant les principales étapes, les résultats obtenus et les perspectives futures.
PPE

Master Management de innovation -  Projet personnel encadré (M1)

T-shirt anti-noyade

ByeBum


24/11/22 -> Entrevue avec Mr MULLER pour présenter le projet ByeBum, nos objectifs nos attentes. Demande formulée pour que Mr MULLER intègre le projet ByeBum en tant que tuteur référent. Son rôle est d'accompagner l'équipe tout au long du projet, de répondre aux éventuelles questions, de nous aider à trouver des éléments de réponses.

27/01/23 -> Tentative de début de modélisation & découverte de Thingivers.com. Rencontre avec une étudiante maitrisant le logiciel de modélisation 3D FreeCad. Nous a initié à Thingivers pour se familiariser avec le monde de la 3D.

03/03/23 -> RDV prévu pour demande de l'aide à la modélisation 3D. Rdv a débuté avec une session de brainstorming principalement autour de notre pince ByeBum. Dessin de notre croquis à taille réelle. -> Téléchargement du logiciel de modélisation 2D Inkscape. Modélisation 2D de la pince. Cette modélisation 2D nous permettra par la suite de modéliser en 3D et passer à l'étape menuiserie.

10/03/23 -> Update par rapport au dernier RDV.

Fruity Bag - Sachet alimentaire en cuir de fruit


Présentation du projet
Nous nous sommes penchés sur la problématique du gaspillage alimentaire, et plus particulièrement le gaspillage des fruits et légumes car ce sont les aliments les plus gaspillés en France. En effet, ils représentent 42% du gaspillage alimentaire, soit environ 4,2 millions de tonnes/an.
On va donc récupérer les fruits et légumes invendus dans les marchés et supermarchés. Avec ces fruits nous allons fabriquer du cuir de fruit, qui est une forme de cuir végétal. Nous allons ainsi utiliser ce cuir de fruit pour fabriquer des sachets alimentaires, pour remplacer les sachets en plastiques et ainsi réduire l’utilisation de plastique.
Matériel

Étapes

Journal de bord

Galeries de photosUE LU3MTT560 - Création d'un événementiel

➝ Porteuses du projet : 

⸱  Cassandra d'ALMEIDA (cassandra.dalmeida.1@etu.sorbonne-universite.fr)
⸱  Maéva DORMANT (maeva.dormant@etu.sorbonne-universite.fr)

➝ Contexte du projet :

Dans le cadre d'une UE de la mineure "Communication et Médiation scientifique", nous, Cassandra d'ALMEIDA et Maéva DORMANT, devons créer un événementiel.

➝ Description générale du projet :

Souvent sollicités par différents laboratoires à l'approche de la Fête de la Science, le Fablab souhaite aider ses utilisateurs à exploiter tout son potentiel. Pour cela, nous nous efforcerons de rassembler et de documenter l'ensemble des projets passés, de les reproduire et de les améliorer. Nous montrerons comment ils auraient pu être poussés plus loin, tout en produisant un document et des éléments de communication. L'objectif final est d'organiser une journée « Préparer la Fête de la Science au Fablab SU » à destination des chercheurs, des étudiants, etc.

➝ Projets "Fête de la science" retenus :

⸱ Tester des connaissances : Le Neuroquizz
⸱ Comprendre la vision d'un insecte : L'abeille
⸱ Les amis et ennemis du climat : Les volcans
⸱ Comprendre un fait scientifique simple : La synthèse soustractive
⸱ Initier à l'astronomie : Les météorites

Tester des connaissances : Le Neuroquizz

➝ Porteurs originaux du projet :⸱ Léonie SOMMACAL (leonie.sommacal@sorbonne-universite.fr)⸱ Agathe GARET (agathe.garet@sorbonne-universite.fr)➝ Contexte du projet :Dans le cadre de la Fête de la science 2022, Léonie SOMMACAL et Agathe GARET ont créé un jeu de questions-réponses pour tester les connaissances du public en sciences. Lors de ce projet, le Fablab a été sollicité pour l'impression (en résine) et la coloration (en dorée) de trophées en forme de cerveaux.➝ Notre contribution :

Badge (pins) :

Design en .svg
Découpe et gravure sur du plexiglas (3 mm)
Découpe et gravure sur du bois (3 mm)

Buzzer :

Impression 3D avec du PLA noir (1,75 mm)
Impression 3D avec de la résine
Génération de son et de lumière avec Arduino

Trophée :

Design en .stl
Impression 3D avec de la résine

Les amis et ennemis du climat : Les volcans

Comprendre un fait scientifique simple : La synthèse soustractive

➝ Porteurs originaux du projet :⸱ *Berfin KARAKILIC (contact : berfin97@live.fr) , projet datant de novembre 2017
N.B : nous avons tenté de la contacter (via mail et Linkedin) mais nous n'avons eu aucun retour.➝ Contexte du projet :Dans le cadre de la mineure Design, Berfin a décidé de mettre en place un jeu expliquant la synthèse soustractive sans passer par le jeu de lumière mais plutôt par le mélange des couleurs. ➝ Pourquoi ce projet ? :

Nous avons repris ce projet car nous le trouvions intéressant dans un contexte Fête de la Science. En effet, il s'agit d'un jeu adapté aux jeunes de 6 à 15 ans pour les aider à mieux comprendre cette loi physique de la synthèse soustractive. Elle a ainsi décidé de réaliser un hand spinner multicolore.
➝ Notre contribution :
Pour l'instant, nous avons reproduis le hand spinner tel quel. Nous cherchons encore à comment l'améliorer.

Projet Fête de la Science pour l'espace biologie-chimie du Fablab

Lors d'un RDV avec Monsieur Hubert (le vendredi 17 février 2023), nous nous sommes convenus qu'il serait intéressant de mettre en avant l'espace biologie-chimie du Fablab à travers un projet Fête de la Science. Après quelques temps de réflexion, nous avons donc pensé à mettre en place un projet autour de la bioluminescence.

Titre du projet FDS : "Un monde de bioluminescence" (titre encore à revoir)
L’objectif serait de sensibiliser le grand public sur les organismes bioluminescents et leur importance dans notre environnement. De plus, on pourrait présenter différentes applications de la bioluminescence dans la vie quotidienne (ex : lampe à bioluminescence)
Etapes :

Une exposition interactive sur les organismes bioluminescents avec des photos, des vidéos et des spécimens (si possible) de différentes espèces . Cela permettrait aux visiteurs de découvrir les mécanismes autour de la bioluminescence, les espèces bioluminescentes et leur répartition  dans les différents habitats.
On pourrait ensuite proposer des expériences pratiques pour découvrir les différentes applications de la bioluminescence dans la vie quotidienne. Par exemple, le public pourrait tenter de fabriquer une lampe de poche bioluminescente ou sinon d’observer la bioluminescence des organismes au microscope. Et pour les enfants, cela aurait la forme d’ateliers pour les sensibiliser au travers des jeux éducatifs et des expériences.
Pour ceux qui le souhaitent, il y aurait des conférences pour approfondir les connaissances sur la bioluminescence. Des enseignants chercheurs pourraient par exemple présenter leurs dernières recherches sur ce domaine.
Pour finir, il y aurait une projection de films/documentaires sur les organismes bioluminescents.

Ainsi, le public pourra découvrir la bioluminescence de manière ludique et interactive. Ils verront qu’il est possible d’appliquer la bioluminescence dans son quotidien et que ce n’est pas un sujet exclusif aux scientifiques.Préparer la Fête de la Science au Fablab SU - Ce qu'il faut retenir...


UE MU5BM617



Projet Velidar

Nom du projet : Vélidar
Coordonnées :

Younes Boujedli : younes.boujedli@gmail.com

Présentation du contexte : 
Inciter les cyclistes urbains à utiliser le vélo comme moyen de transport quotidien, en mettant un frein au sentimentd'insécurité en ville, grâce à un dispositif intégrable à un vélo électrique pour permettre la détection des véhicules dans l'angle mort des cyclistes.
Description du produit :

Le dispositif est composé de deux modules, un module de détection de véhicule et un module de visualisation du signal, les deux dispositifs sont reliés par un câble.

Module de détection : Fixation sur la tige de selle, il a pour objectif de détecter et évaluer la vitesse des véhicules en mouvement sur une distance de 2 à 15 mètres avec un angle de détection important (technologie Doppler). En plus, il déterminera la distance du véhicule en approche à une distance de 0 à 8 mètres (Technologie Lidar).

Module de visualisation : Fixation sur le guidon, ce module transmet à l'utilisateur un signal lumineux (bar led 10 segment) et devra être visible en plein jour. Le module de visualisation est composé de 10 led avec 4 couleurs différentes (bleu, verte, jaune, rouge), qui s'allume en fonction d'un score de danger calculé par le module de détection allant de 0 à 9.

Matériaux / Outils / Machines :

module visualisation :

1 : bar 10 led segment prix 0,91€ (satisfait du composant)
2: multiplexeur i2C (prix 0,92€) #pour optimiser l'utilisation des pin sur la board  ( voir utilité du composant ou alternative ?)
Module détection :

3: batterie lipo 3,7V 1800mAh prix 4,82€ #(certains composants nécessite une tension de 5V, batterie pas assez puissante ?)

4: batterie management (prix 4,54 €) # interrupteur intégré et permet la gestion de la batterie (utile ?)
5: Micro-controleur Xiao SAMD21 avec port usb-C (4,89€ ) (alternative ?)
6:

module d'amplification pour doppler  prix ( 0,35€)

7: Module doppler 24G prix ( 3,39€) # détecte les véhicules et leurs vitesses à une grande portée mais pas la distance

8: Lidar Luna 8m de portée prix (24,38€) # angle de détection très restreint et très cher, alternative Vl53l1X ? portée 4m prix 16,87€

Technologie de Détection :
Choix du capteur : Utilisation de capteurs LIDAR (très peu d'angle de détection -> très linéaire et peu de distance), mais très précis et radar à ondes millimétriques Doppler pour un angle plus grand mais pas de mesure de distance.

Détection d'objet en mouvement uniquement (vélo, voiture, scooter) minimum 10km/h

Détection d'objet en mouvement minimum 45° principalement véhicule arrivant derrière le cycliste mais également sur la gauche (détection sur le coté droit non nécessaire)
Voir pour l'intégration de capteurs additionnels (optionnel) pour améliorer la détection.

Montage et installation :

Système de montage facile et sécurisé, compatible avec différents modèles de vélos.
Coque résistance à l'eau (pluie), poussières et aux chocs. (à définir)

Conformité et Sécurité :

Conformité aux normes de sécurité routière et aux réglementations électroniques.
Tests de sécurité et de durabilité.

Dimensions et Poids :

Conception compacte et légère pour minimiser l'impact sur la maniabilité du vélo.

Budget et Coût

Estimation du coût de la matière première prototype 30 euros

Mise en application : 
Annexe :

Tableau scoring pour allumage Led

0 = led bleu // entre 1 et 4 = led verte // entre 5 et 7 = led Jaune // score supérieur à 8 = led rouge

Score calculé par le module de détection
situation

Couleur Led

0
aucun véhicule détecté à moins de 15 mètres
Bleu

entre 1 et 4
Véhicule détecté par le doppler uniquement à une vitesse d'approche inférieur à 15km/h de différence par rapport au cycliste ( Véhicule entre 15 et 8 mètre)
Vert

entre 5 et 7
Véhicule détecté uniquement par le doppler à une vitesse supérieur à 15km/h de différence par rapport au cycliste OU véhicule détecté par le Doppler à une vitesse d'approche inférieur à 15km/h et par le Lidar à une distance entre 8 et 4 mètres
Jaune

supérieur à 8
Véhicule détecté par le Doppler uniquement à une vitesse d'approche supérieur à 30km/h (véhicule entre 15 et 8 mètres) OU véhicule détecté par le Doppler à une vitesse d'approche supérieur à 15km/h et par le Lidar à une distance entre 8 et 4 mètres OU Véhicule détecté par le Doppler à une vitesse d'approche inférieur à 15km/h et par le Lidar à une distance entre 4 et 0 mètres
Rouge

formule scoring : Score(vitesse du véhicule_Doppler) + Score(Distance du véhicule_Lidar) = ScoreTotal_Led
Score(vitesse du véhicule_Doppler) = 0km/h = 0point ; entre 1 et 5km/h = 1point; entre 5 et 10 km/h = 3 point; entre 10 et 15 km/h = 4 point ; entre 15 et 20km/h = 5 point; entre 20 et 30km/h = 6point ; entre 30 et 35km/h = 7 point; supérieur à 35km/h 8 point.
Score(Distance du véhicule_Lidar) = entre 8 et 6 mètre : 2 point // entre 4 et 2 mètres = 6 point // entre 2 et 0 mètres = 10 point

UE LUS2V321- Physique des grandes fonctions des organismes vivants

2022-2023

Sensation de chaud et de froid


Informations

NGUYEN Sylvie, Wu Alias Ren Christine, Ferreira Taylor
Nlchi9175@gmail.com, Wualiasren@gmail.com, taylorferreira00@gmail.com
L2 Sciences de la vie
6 décembre 2022  : 15h-17h

Contexte
Réalisation d'un projet dans l'UE LU2SV321.
PROJET : Sensation de chaud et de froid
Objectifs
Mesurer la température d'une plaque en bois et d'une plaque en cuivre. mesurer le temps de font de la glace sur les deux plaques, en mettant en avant la conductivité.

Matériel

plaque de bois
plaque de cuivre
balance
récipient
glace
caméra thermique

Étape 1
Mesure de la température des deux plaques, de l'air ambiante et de la glace à l'aide de la caméra thermique
Étape 2
Dépot de la glace sur les deux plaques.
Étape 3
Conclusion des résultats sur la conductivité des plaques
Robot a retour Kinésthésique



Description du Projet

Contexte :
Le Cybathlon-VIS est une compétition scientifique et technologique, au cours de laquelle des personnes en situation de handicap participeront à des épreuves, le tout accompagné par une équipe de scientifiques, démontrant ainsi l'apport des technologies pour les personnes en situation de handicap. La prochaine édition de la compétition aura lieu en 2024. Notre projet consiste à développer une technologie permettant de répondre aux objectifs du concours.
Ce projet est en cours, et sera terminé vers le mois de juin 2023. A cette date, nous avons déjà le design de notre robot, et nous essayons de le contrôler à l'aide de moteurs, et d'une caméra Kinnect, ainsi que de divers capteurs. Il s'agit d'un projet d'un an. Nous sommes une équipe de 4 étudiants.
Ce projet est en collaboration avec le laboratoire français ISIR (Institut des Systèmes Intelligents et robotique). https://www.isir.upmc.fr/
L'algorithme derrière le contrôle de notre robot est basé sur le SLAM. Toutes nos implémentations seront faites en utilisant ROS.
Conception et modélisation 

EI2I5 S09



Projet kit'roule

Création d'un kit de motorisation pour fauteuil roulantModubord

MU5EU001

Projet Master 2 Géphysique-Géotechnique

Projet maquette capteur MEMS

UE MU5RBI10 - M2 SPI - Projets de Fin d'Etudes



Groupe 3 - Véhicule autonome

Réalisation d'un véhicule autonome au format 1/10ème en vue d'une participation à une course organisée par l'ENS.
Informations

Tom DA SILVA-FARIA

tom.da_silva-faria@etu.sorbonne-universite.fr
M2 ISI

03/01/2023 - Fin juin 2023 (date de la course : 15 Avril 2023)

Contexte
Le but de ce projet est de réaliser un robot autonome compétitif à partir d'un châssis de voiture télécommandée au format 1/10ème. Ce robot sera engagé dans une compétition de véhicules autonomes organisée par une équipe enseignante de l'ENS Paris Saclay. Ce concours aura lieu le15 Avril 2023 et réunira plusieurs équipes d'étudiants issus de différentes formations (écoles d'ingénieurs, facultés…).
Notre équipe de projet est constituée de 4 étudiants du M2 SAR (Justin BRUGIERE, Alexandre BOTTRAUD, Omar EL OUAFI et Montacir DRISSI) et 2 étudiants du M2 ISI (Yuwang CHEN et Tom DA SILVA-FARIA). Ce projet est encadré par Mr. Sylvain ARGENTIERI.

Objectifs
L'intégralité du véhicule doit être réalisée. Nous disposons d'un châssis TAMYIA TT02 sur lequel nous devrons disposer différents composants électroniques (Raspberry Pi, Arduino, capteurs…) qui permettront au robot de calculer sa trajectoire de manière efficace et autonome.

La course se déroulera sur une piste inconnue à l'avance, qui pourrait ressembler à celle-ci :

Matériel
Nous disposons actuellement du matériel suivant :

1 châssis TAMYIA TT-02 équipé d'un servomoteur (direction des roues) et d'un moteur DC 10A (4 roues motrices)
1 LIDAR (RpLidar A2) pour disposer d'une vue à 360° des obstacles et des parois de la piste autour du robot

Plusieurs capteurs de distance TOF (VL53L1X) (pour détecter en urgence d'éventuels obstacles)
1 Camera avec zoom et autofocus (IMX477 12Mpx B0272)
1 Raspberry Pi 3B+ qui servira d'ordinateur de bord (traitement des données des capteurs et des images + calcul de trajectoire)
1 Microcontrôleur type Arduino NANO qui convertira les commandes de vitesse/direction des roues en signaux PWM pour le contrôle des actionneurs (moteur et servomoteur)

Nous disposons enfin d'un jeu de composants électroniques (transistors de puissance, relais, fusibles…) qui nous permettront de réaliser une carte de conversion des signaux PWM en signaux continus suffisamment puissants pour commander le moteur DC.

Machines utilisées
Nous faisons appel au FabLab pour la découpe de pièces en contre-plaqué pour la réalisation du support des composants et de la carrosserie du véhicule. Nous aimerions pour ce faire utiliser une des découpeuses Laser disponibles au FabLab (Trotec Speedy 100 ou 360).
Journal de bord
05/01/2022
A l'heure de l'écriture de cette page, la carrosserie et le support des composants ont été dessinés sous SolidWorks. Nous avons également mis en place sous WeBots un simulateur qui nous permettra de prototyper nos algorithmes avant de les tester sur le robot réel.MU4CIOIP



Tournois Français de Chimiste edition 2023(fil rouge OIP M1 )

Pour plus d'info sur le tournois https://www.tfchim.fr/

Sujet étudié:

Sujet 4: Persistance de la chimie
La mesure du temps est globalement restée, depuis que sa nécessité s’est imposée au cours de l’évolution humaine, une affaire de physiciens. Que ce soient l’observation directe des astres, les cadrans solaires, sabliers et clepsydres, puis les pendules mécaniques, mécanismes à quartz puis horloges atomiques, le rôle des chimistes s’est principalement limité à la fourniture des matériaux supports à la réalisation de ces différents types d’horloges.
​
• Pourtant, serait-il possible de mettre au point un système chimique permettant une mesure temporelle, et reposant sur le déroulement d’une réaction ? Ce système, pour être compétitif,devrait pouvoir être simple d’utilisation, réutilisable, et se montrer déclinable pour remplir diverses fonctions : minuteur, alarme, chronomètre, ou simple horloge, par exemple.

3 idées ont été envisagé

La manip faite majoritairement au fablab est celle ci:

L'idée derrière est améliorer ce système pour faire une horloge fiable en utilisant ce phénomène de phosphorescence.
Pour ce faire il faut reproduire ce système dans plusieurs compartiment sombre, pour des raisons pratiques 4 systèmes.

janvier 2023 La boite je l'ai faite avec un site en ligne, mais j'ai mal mesuré la taille des trous... tant mieux j'ai réimprimé des support pour les petite pastille phosphorescente (en bleu). La led UV de 10W(12v) pour l'autre expérience nécessitait un radiateur de dissipation thermique.  l'autre led de 3w fonctionne en 2,9v 70mA sans surchauffe, donc sans radiateur.
un petit aperçus de comment ça pourrait fonctionner à l'avenir
https://youtube.com/shorts/g_E8NuoqtWY?feature=share

UE LU1LVAN2



Atome en carton

Informations

Pola SZOPKA, Angèle EDMOND, Paul CAMUS
pola.szopka@etu.sorbonne-universite.fr , angele.edmond@etu.sorbonne-universite.fr , paul.camus@etu.sorbonne-universite.fr

CMI Physique — Anglais
04/04/2023 —> 06/04/2023

Contexte
Dans le cadre de notre UE d’anglais nous devons créer une affiche pour présenter le thème de « why should you study physics ? ».
Objectifs
Nous voulons découper par laser un morceau de carton en forme de 3 eclipses qui représentent les orbitales d’un atome et 6 ronds représentants les électrons. Les orbitales seront de 60*10 tandis que les électrons seront de 5cm de rayon.
Par ailleurs, nous souhaitons aussi faire un système grâce auquel nous pouvons faire des électrons une image derrière laquelle se trouve un texte donc pouvoir enlever une premiere couche de l’électron et y découvrir une description de l’image.
Matériel

3 planches de cartons de minimum 60*15cm
2 planche de carton 35*35cm
cutter

Machines utilisées
Trotec Speedy 360
Construction
Voici le lien vers le fichier SVG du dessin de la découpe.
anglais_cmi.svg

Étape 1
Dans un premier temps, nous devons dessiner les éclipses et les cercles sur Inkscape en rentrant la taille souhaitée.

Étape 2
Ensuite, il faut programmer la machine en fonction du carton que l’on utilise, en l’occurrence du carton standard d’expédition. L’épaisseur de celui étant de 3,80mm, une épaisseur non répertoriée sur le logiciel de la découpeuse. Il faut que nous modifions la puissance du laser en fonction d’un matériau ressemblant à notre carton, du carton 0,8cm étant déjà répertoriée, il nous suffit de réduire sa puissance pour configurer la machine selon nos besoins.
Pour commencer, on va dans la base de donnée des matériau on sélectionne le carton 0,8cm ensuite il faut sauvegarder comme nouveau programme puis une page s’affiche dans laquelle on peut modifier la puissance et la vitesse du laser. On augmente la puissanté à 42% et on diminue la vitesse à 1,2%. Le test effectué avec des figures au hasard étant concluant, nous pouvons désormais appliquer ce programme aux découpes souhaitées. Le nouveau programme de découpe s’appelle CardBoard 3mm.

Étape 3
La découpe étant finie, il ne nous reste plus qu’à assembler le tout en coupant les parties qui se chevauchent et y introduisant les électrons. EPU-M7-8-DPR



Découpe laser plaques résine

Informations

Cyprien Desbordes, Gustavo Lins et Louella Pinel
mtx.polytech@gmail.com
MTX4 - Polytech Sorbonne
14/04/23 - 22/05/23

Contexte
Dans le cadre de notre formation élève ingénieur à Polytech Sorbonne en quatrième année de MTX, nous avons l'opportunité de réaliser un projet en relation avec un industriel. L'objectif de ce projet est de réaliser une monture de lunettes en composite organique avec une matrice polymère et une charge. La charge utilisée est issue de l'usinage des palets de verre organique qui servent à faire les verres de lunettes.
Objectifs
La raison de notre venue au FabLab est d'utiliser la découpeuse laser afin de détailler nos échantillons de traction et de flexion pour pouvoir caractériser les propriétés mécaniques de nos composites. Nous envisageons également de découper une monture de lunettes pour la fin du projet pour pouvoir la présenter lors de notre soutenance.

Matériel

plaques composite à base de résine GreenPoxy56 et de copeaux de CR39. Ces plaques ont été réalisées dans le laboratoire de M. Ferrier (tuteur académique du projet)

Machines utilisées
Trotec Speedy 360
Construction
(Fichiers, photos, code, explications, paramètres d'usinage, photos, captures d'écran...)
Étape 1
Réalisation des plaques aux dimensions souhaitées selon les dimensions des éprouvettes
Étape 2
Réalisation du fichier .svg pour la découpeuse laser
Étape 3
Découpage des plaques
Étape 4
Caractérisation des propriétés mécaniques
Journal de bord
14/04/2023
Découpe des premières plaques test
18/04/2023
Découpe des secondes plaques test
21/04/2023
Découpe des premières plaques pour les tests mécaniquesEPU-R7-8-DPR



Réalisation d'une boîte en bois

Informations

Alexandre VIEU et Tancrède SOURICE
tancrede.sourice@gmail.com
ROB4
17/03/2023

Contexte
Nous cherchons à modéliser un objet de forme parallélépipédiquedont les dimensions sont : 500x400x300 et de masse=23kg
Objectifs
Réaliser une boîte en bois capable d'accueillir des 4 disques de 5kg et 1 disque de 1kg qui peut se déplacer le long d'un axe.

Matériel

4 planche de CP peuplier 6mm (dimensions 300*600mm)
tasseaux de bois
colle à bois
vis

Machines utilisées
Trotec Speedy 360
Construction
Étape 1
Réalisation des plans sur solidworks : cote_court.DXF ; cote_long.DXF ; dessous.DXF
Étape 2
Découpe laser des planches de CP peuplier 6mm

Étape 3
Assemblage (à faire)
LU3S01



Batteur à houle


Informations

HAMMJE Nicolas
me@nicolashammje.com
Laboratoire Jean le Rond d'Alembert
10/15/22 - 06/01/23

Contexte
Dans le cadre de la L3 Mono-intensive mécanique, les étudiants doivent réaliser un stage dans un laboratoire de leur choix. Ici, le stage fut réalisé au laboratoire Jean le Rond d'Alembert, et consistait en la réalisation d'un batteur à houle pour le bassin à vagues du laboratoire. Le laboratoire disposait déjà d'un batteur à houle, mais souhaitait une solution plus modulable, avec un contrôle par ordinateur.

Objectifs
L'objectif primaire était de revoir la base du batteur à houle original pour permettre d'y intégrer des servomoteurs Dynamixel, puis d'intégrer le tout dans un beau boitier et finalement écrire un code rudimentaire mettant en avant les différentes capacités du nouveau batteur.

Matériel

1 batteur à houle
PLA
ASA
2 Dynamixel XL-330
1 U2D2 + U2D2 Power Hub
4 roulements  MR105

Construction

Plus d'infos sur nicolashammje.com, projet 'WaveMaker'LU3MEP10



Machine Filament

Informations

Emile Assine
emile.assine@etu.sorbonne-universite.fr
Cursus: Innovation et développement Industriel
06/06/2023 - 08/06/2023

Contexte
Nous sommes un groupe de 5 étudiants et dans le cadre de notre formation à la Sorbonne Université, nous avons comme projet de fin d'étude la réalisation d'un prototype d'une machine qui vise à recycler les bouteilles en plastique pour en faire du filament pour imprimante 3D.

Objectifs
La machine se chargera de découper automatiquement la bouteille en plastique. Puis le morceau découper passera par un "corp de chauffe" qui va chauffer le plastique à 200°C pour le faire fondre. Ce plastique fondu sortira par une buse avec un petit diamètre qui le transformera  en filament. Celui-ci sera enroulé de manière automatique sur un rouleau qui tourne grâce à un petit moteur et un système d'engrenage.

Nous devrons donc imprimer en 3D au Fablab quelques unes des pièces qui vont composer ce cette machine.
Matériel

1 rouleau de PLA

Machines utilisées

Imprimante 3D

Journal de bord
06/06/2022
Lancement des pièces de notre prototype sur trois imprimantes 3DBras exosquelette

UE 604 Diversité des organismes en milieux naturels

Découpe laser plaques résine

Projet Ilicare Patches UV pour la peau

Stage ISCD + Tilt Five+Unreal Engine

Polytech ROB3-Projet Robotique

UE pour les élèves de Polytech ROB3 - L. Carillet et G. Morel

Le sujet du projet

Projet de robotique 
ROB3 – S6 – 2024

1.

 Objectifs
L’objectif de ce projet est de concevoir et réaliser un système robotique, c’est-à-dire sa partie mécanique, sa motorisation, sa commande et son interface de pilotage. Le cahier des charges fourni précise les fonctions que doit réaliser le système et les contraintes qu’il doit respecter.
Pour les étudiants, l’objectif est au moins autant d’apprendre par la pratique les bases de la gestion d’un projet (c’est-à-dire la façon de s’organiser en équipe pour atteindre un objectif donné avec des moyens donnés) que d’aboutir à un prototype fonctionnel.
2.

 Cahier des charges
Le but général est de faire un robot capable de dessiner avec un crayon sur un support plan horizontal.
2.1 Fonctions à réaliser 
Le robot doit être fixé ou posé sur une plaque horizontale carrée de 250mm par 250mm. Il doit être capable de réaliser deux exercices :
1)

 Tracer, avec l’aide d’un crayon fixé sur l’organe terminal du robot, dans le plan de la plaque support différentes figures imposées de difficulté croissante :
a.

 Une ligne de 5cm de long,
b.

 Une ligne pointillée de 5cm de long,
c.

 Un cercle de 2.5cm de rayon,
d.

 Un cercle pointillé de 2.5cm de rayon.
Le tracé de chacune des figures doit être réalisé en 10 secondes +/- 0.2 secondes.

2)

 Tracer, avec l’aide d’un crayon fixé sur l’organe terminal du robot, dans le plan de la plaque support, un dessin imposé dans un carré de 5cm par 5cm. Le déplacement de l’organe terminal du robot devra être piloté par un joystick. Il est possible que la figure soit discontinue, et donc il faut prévoir de pouvoir relever le crayon du support horizontal sur lequel on écrit.

Une fonction supplémentaire, optionnelle , peut être réalisée :
• Être capable de modifier la vitesse de déplacement du robot via l’interface.

2.2 Fonctions contraintes 
Les contraintes imposées sont :
•

 Respect des règles d’utilisation du FABLAB de Sorbonne Université au sein duquel vous travaillerez, en particulier la charte des FabLab du MIT. Cela implique que vous travaillerez sur le WIKI du FABLAB pour documenter votre projet. Il y a une bonne documentation ici pour savoir comment utiliser le WIKI.
•

 Utilisation de composants (moteurs, contrôleurs, boutons, éléments de guidage, alimentation stabilisée, boutons, etc.) parmi un ensemble imposé. Une liste de composants utilisables est disponible au paragraphe 4.  
•

 Fabrication des pièces grâce à :
o Machine à découpe LASER.
o Imprimantes RAISE 3D PRO2.
 Ces machines du FABLAB de sont pas toutes accessibles tout le temps ni en même temps. C’est une contrainte qu’il vous faut intégrer dans la gestion de votre projet (par exemple, privilégier la découpe LASER qui est très rapide, lorsque c’est possible).

           Un objectif est de minimiser la quantité de matière utilisée pour réaliser le projet.
•

 Programmation en C utilisant la chaîne de développement Arduino IDE.
3.

 Organisation
Les étudiants sont organisés en groupe de 3 dans la mesure du possible. Chaque groupe bénéficie de 6 séances encadrées tout au long du semestre.
En dehors des séances encadrées, il est possible d’accéder au FABLAB en accès libre les lundis, mardis, jeudis et vendredis de 14h à 18h30. Pour cela il faut s’adresser au FABLAB.  
Le suivi des objectifs est un élément essentiel de la gestion de projet. Il a pour but de situer l’avancement du projet. Pour ce premier projet réalisé dans le cadre de votre cursus, des objectifs intermédiaires sont fixés par l’équipe enseignante afin d’éviter des erreurs de planification liées à l’inexpérience. Les objectifs sont ici exprimés en termes de livrables, qui sont les suivants :
1.

 Avant le début de la deuxième séance :  
o

 Remise d’un dossier de conception préliminaire. Il s’agit d’un dossier qui précise les choix généraux faits pour la solution que vous allez mettre en œuvre.  
o

 Remise d’un diagramme de GANTT : il s’agit d’un schéma qui précise qui-fait-quoi-quand.
2.

 Cinq jours après la fin de la troisième séance : remise d’un dossier de conception détaillée. Il s’agit d’un dossier qui précise tous les choix technologiques faits. Ce dossier contient notamment la CAO, les schémas électriques de connexion et les algorithmes de commande. Lorsqu’un dossier de conception détaillé est bien fait, en principe, le reste du projet consiste à réaliser le prototype en se référant à ce dossier.
3.

 Au plus tard 2h avant la fin de la dernière séance : 
o

 Démonstration finale de réalisation des deux exercices.
Comme le timing est très serré, si des objectifs intermédiaires ne sont pas atteints, l’équipe enseignante fournit à l’équipe projet une solution type qui permet de poursuivre le projet selon le déroulement prévu.
4.

 Liste des composants et matériels disponibles
•

 Un crayon
•

 Interface de commande : 
o  Une carte arduino UNO avec câble USB-B;
o  Un joystick; 
o  Une platine de protoypage; 
o  Alimentation régulée 5V ; 
o  Câbles, LEDs, boutons poussoirs, résistances. 
•

 Motorisation : 
o  Deux servomoteurs HS422 180°;
o  Un servomoteur Emax ES08A 180°. 
•

 Mécanique : 
o  Matière PLA pour impression 3D;
o  Feuilles medium : 3mm et 6mm d'épaisseur;
o  Vis et écrous : M2, M2.5, M3, M4.
o  Roulements et axes de diamètre 4mm. 

Projet robotique 3-A Robot écrivain Bastien Antonin Antonin

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 🤩🤩🤩Impression 3D électrochimique : Réalisation d'un réseau d'électrodes

None