Super Groupe A1

Séance 1 - 30/01/2024

C'est notre 1ère séance de l'UE [1] projet fablab ! L'objectif de cette UE sera de nous introduire les outils du Fablab puis de nous laisser réaliser notre propre projet. La séance s'est décomposée en deux grandes parties : une présentation générale de l'histoire des Fablab, de ce que nous allons faire dans l'UE. Puis nous avons fait un tour du lieu et des outils qui le composent.

L'idée de recréer le "technicien du garage" nous a beaucoup plus, et les outils à notre disposition nous permettent de réaliser presque tout, laissant libre cours à notre esprit créatif. Nous sommes motivé quant à la suite de cet enseignement, et impatient d'en découvrir les retours sur investissement !

Le fablab de Sorbonne UPMC se décompose en 5 grandes parties :

• La salle de "brainstorming" (ou tempête de cerveau), où nous pouvons faire des recherches, mettre nos idées à plats, revoir la théorie... Des ordinateurs avec accès à internet, des livres ainsi que des tableaux et des feutres sont mis à disposition. On peut aussi y trouver des composants électroniques et des outils bricolages dans des rangements spécifiques.
• Une salle d'impression 3D, où nous pouvons imprimer des objets en volume selon le patron numérique réalisé sur un logiciel ou repris sur internet. On peut y imprimer des mécanismes en une fois, sans post-montage (image 3).
• Une salle de découpage laser ou à jet d'eau sous pression permettant la création de pièces dans tous types de matériaux (bois, métal...) (image 1 et 2).
• Une salle où nous pouvons graver des circuits imprimer à l'aide de lasers ou de fraiseuses accompagnée d'un espace soudure.
  
• Une salle de menuiserie possédant toutes les machines nécessaires pour travailler le bois.

Nous vous mettons quelques photos d'objets créés au fablab que nous avons prises durant la 2ème partie du cours (la visite).

                     Image 1 : Morceaux de bois découpés                              Image 2 : Patron de cerf découpé puis assemblé

Image 3 : Objets imprimé en 3D 

[1] : Unité d'Enseignement

Séance 2 - 06/02/2024

Notre seconde séance c'est décomposé en deux axes majeurs.

Nous avons dans un premier temps découvert et essayé différents logiciels de design 2D avec Inkscape et 3D avec OpenScad et FreeCad. Monsieur Vincent nous entrecoupait son cours d'exercices d'applications sur ces logiciels.

La particularité d'OpenScad est que l'interface est textuelle ! C'était très différent de ce que l'on a déjà fait auparavant ou fait sur Inkscape ou FreeCad. Ils sont tous les 3 libres d'accès (téléchargements gratuits) et leurs codes sources est publié. Ce sont des outils transparents, avec lesquels nous sommes assurés de notre droit d'auteur : des logiciels "propriétaires", peut-être plus efficaces en termes d'interfaces, pourraient extraire certains de nos modèles.

Pour prendre en main les logiciels nous avons réalisé pendant la séance quelques formes géométriques respectant plusieurs contraintes qui nous avait été données. 

Par exemple, un carré dont les 4 coins contiennent des cercles sur Inkscape.

Figure réalisée sur Inkscape

Ou un cube pour lequel on a soustrait 3 cylindres sur OpenScad.

Forme réalisée sur OpenScad

Code utilisé pour réaliser ce cube

Nous avons également réalisé la même figure sur FreeCad. Sur ce logiciel, l'interface était moins intuitive que sur OpenScad, bien qu'elle n'était pas textuelle !

Puis, dans un second temps, Clara, une Fablab Manager, diplômée du diplôme supérieur des responsable fablab, nous a montré comment utiliser les logiciels associés aux découpeuses lasers et imprimantes 3D et a fait une démonstration du fonctionnement des premières en découpant et gravant un petit morceau de bois. En ce qui concerne les découpeuses lasers, on peut par exemple faire plusieurs teintes de gravures (en gris) et découper par là même ! Elle nous a montré que les découpeuses sont bien plus rapides que les imprimantes 3D ainsi que les conditions d'utilisation.

Séance 3 -13/02/2024

Dans un premier temps, nous avons été introduis l'Arduino ! C'est une carte en circuit intégré complexe, réduit, composé d'un microcontrôleur. Avec une carte Arduino, nous pouvons programmer des actions à l'infini ! En effet, il n'y a plus besoin de souder un circuit pour réaliser chaque tâches que l'on veut : une carte Arduino peut être programmée et reprogrammé pour réaliser des actions complètements différentes (dans la limites des capteurs et actionneurs reliées à celle ci)

Nous avons premièrement réalisé un programme blink, lequel est ci dessous.

void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(2, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(2, HIGH);  // turn the LED on (HIGH is the voltage level)
  delay(1000);                      // wait for a second
  digitalWrite(2, LOW);   // turn the LED off by making the voltage LOW
  delay(200);                      // wait for a second
  digitalWrite(2, HIGH);  // turn the LED on (HIGH is the voltage level)
  delay(300);                      // wait for a second
  digitalWrite(2, LOW);   // turn the LED off by making the voltage LOW
  delay(200);
  digitalWrite(2, HIGH);  // turn the LED on (HIGH is the voltage level)
  delay(1000);                      // wait for a second
  digitalWrite(2, LOW);   // turn the LED off by making the voltage LOW
  delay(200);
  digitalWrite(2, HIGH);  // turn the LED on (HIGH is the voltage level)
  delay(300);                      // wait for a second
  digitalWrite(2, LOW);   // turn the LED off by making the voltage LOW
  delay(1000);
  digitalWrite(2, HIGH);  // turn the LED on (HIGH is the voltage level)
  delay(300);                      // wait for a second
  digitalWrite(2, LOW);   // turn the LED off by making the voltage LOW
  delay(200);
  digitalWrite(2, HIGH);  // turn the LED on (HIGH is the voltage level)
  delay(300);                      // wait for a second
  digitalWrite(2, LOW);   // turn the LED off by making the voltage LOW
  delay(200);
  digitalWrite(2, HIGH);  // turn the LED on (HIGH is the voltage level)
  delay(1000);                      // wait for a second
  digitalWrite(2, LOW);   // turn the LED off by making the voltage LOW
  delay(1000);
  digitalWrite(2, HIGH);  // turn the LED on (HIGH is the voltage level)
  delay(1000);                      // wait for a second
  digitalWrite(2, LOW);   // turn the LED off by making the voltage LOW
  delay(200);
  digitalWrite(2, HIGH);  // turn the LED on (HIGH is the voltage level)
  delay(1000);                      // wait for a second
  digitalWrite(2, LOW);   // turn the LED off by making the voltage LOW
  digitalWrite(2, LOW);   // turn the LED off by making the voltage LOW
  delay(5000);
}

Blink_morse.ino (fichier du code)

Le 2ème exemple de code pour Arduino était avec un capteur d'humidité et de température. Voici le code ci-dessous (code que l'on retrouve sur le site du vendeur)

#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);
}

Arduino_Capteur.ino (fichier du code)

Ces codes peut être écrit dans l'application Arduino IDE 2.3.2, libre de droit.

Il suffit alors de brancher le capteur sur la carte et d'envoyer ce code sur la carte Arduino pour faire fonctionner le système. Les cartes Arduino sont très faciles d'utilisation et le fait que les codes sont souvent déjà fourni avec les composants utilisés nous permet de construire et d'utiliser des composants électroniques sans connaissances en codage.

En deuxième partie, nous avons continuer notre recherche de projet. Maintenant que nous connaissons tout les objets et machines à notre disposition, nous avons une idée plus claires de ce qui était à notre porté. Nous ne nous sommes pas encore décidé mais avons déjà quelques pistes concrètes. 

Voici notre 1ère planche de brainstorming.

Séance 4 -27/02/2024

Ceci est la première séance de réalisation de notre projet.

Nous avons au départ hésité entre un thermostat intelligent, un détecteur de qualité d'acoustique d'une pièce, et un détecteur de gaz pour donner la qualité de l'air. C'est finalement ce dernier projet que nous allons réaliser. Nous pensions aussi décliner notre projet en un ballon, qui analyserait les gaz en altitudes, ou tout simplement un capteur d'incendie / de viabilité de l'air dans une pièce (plus d'aération, etc).

Nous pensons y avancer par étapes :

• Tester les capteurs (particules fines, HCHO, et autres)
• Monter un 1er prototype, puis le tester
• Augmenter l'autonomie de notre projet (batterie externe, stockage de l'information)
• Concevoir un ballon qui puisse monter à une certaine altitude avec tout le matériel (ajouter un altimètre)
• Tester un Prototype, l'améliorer....
• Présenter notre projet 
  

Voici le site informatif du capteur principal, le détecteur de particule/poussière (Laser PM25 Sensor) : https://wiki.seeedstudio.com/Grove-Laser_PM2.5_Sensor-HM3301/#software

Voici le site informatif du capteur secondaire, le détecteur de gaz (Grove - HCHO Sensor) : Grove - HCHO Sensor | Seeed Studio Wiki

Voici un lien qui nous a aidé à installer la bibliothèque qui permet à l'Arduino de communiquer avec ce capteur : https://wiki.seeedstudio.com/How_to_install_Arduino_Library/

Voici le code basique pour faire fonctionner le capteur Laser PM25 Sensor. Actuellement, il nous renvoie NNNN, mais seulement une est importante : . En effet, c'est ce composé qui peut NNNN et qui est rejeté notamment par NNNN.

Nous comptons l'améliorer afin qu'il renvoie un graphique de l'évolution des concentrations en gaz en fonction du temps (puis en fonction de l'altitude si on réussi à aller au bout du projet).

#include <Seeed_HM330X.h>

#ifdef  ARDUINO_SAMD_VARIANT_COMPLIANCE
    #define SERIAL_OUTPUT SerialUSB
#else
    #define SERIAL_OUTPUT Serial
#endif

HM330X sensor;
uint8_t buf[30];


const char* str[] = {"sensor num: ", "PM1.0 concentration(CF=1,Standard particulate matter,unit:ug/m3): ",
                     "PM2.5 concentration(CF=1,Standard particulate matter,unit:ug/m3): ",
                     "PM10 concentration(CF=1,Standard particulate matter,unit:ug/m3): ",
                     "PM1.0 concentration(Atmospheric environment,unit:ug/m3): ",
                     "PM2.5 concentration(Atmospheric environment,unit:ug/m3): ",
                     "PM10 concentration(Atmospheric environment,unit:ug/m3): ",
                    };

HM330XErrorCode print_result(const char* str, uint16_t value) {
    if (NULL == str) {
        return ERROR_PARAM;
    }
    SERIAL_OUTPUT.print(str);
    SERIAL_OUTPUT.println(value);
    return NO_ERROR;
}

/*parse buf with 29 uint8_t-data*/
HM330XErrorCode parse_result(uint8_t* data) {
    uint16_t value = 0;
    if (NULL == data) {
        return ERROR_PARAM;
    }
    for (int i = 1; i < 8; i++) {
        value = (uint16_t) data[i * 2] << 8 | data[i * 2 + 1];
        print_result(str[i - 1], value);

    }

    return NO_ERROR;
}

HM330XErrorCode parse_result_value(uint8_t* data) {
    if (NULL == data) {
        return ERROR_PARAM;
    }
    for (int i = 0; i < 28; i++) {
        SERIAL_OUTPUT.print(data[i], HEX);
        SERIAL_OUTPUT.print("  ");
        if ((0 == (i) % 5) || (0 == i)) {
            SERIAL_OUTPUT.println("");
        }
    }
    uint8_t sum = 0;
    for (int i = 0; i < 28; i++) {
        sum += data[i];
    }
    if (sum != data[28]) {
        SERIAL_OUTPUT.println("wrong checkSum!!");
    }
    SERIAL_OUTPUT.println("");
    return NO_ERROR;
}


/*30s*/
void setup() {
    SERIAL_OUTPUT.begin(115200);
    delay(100);
    SERIAL_OUTPUT.println("Serial start");
    if (sensor.init()) {
        SERIAL_OUTPUT.println("HM330X init failed!!");
        while (1);
    }

}


void loop() {
    if (sensor.read_sensor_value(buf, 29)) {
        SERIAL_OUTPUT.println("HM330X read result failed!!");
    }
    parse_result_value(buf);
    parse_result(buf);
    SERIAL_OUTPUT.println("");
    delay(5000);
}

Notre première étape a consister à allumer une LED lorsque le tôt de particules détectées dépassait un certain cap. Nous avons définis ce cap par une valeurs légèrement inférieure à celle affichée lorsqu'une allumette était soufflée juste à côté du capteur. Soit :

void setup() {
    pinMode(2, OUTPUT);
}

void loop() {
    if("PM2.5 concentration(CF=1,Standard particulate matter,unit:ug/m3): ">=920)
    {
      digitalWrite(2, HIGH);
      
    }
}

On pensait aussi à faire clignoter la LED lorsque les détecteurs captaient un niveau trop important de gaz.

Nous nous sommes alors familiarisé avec les élément du 1er capteur, il est maintenant temps de nous familiariser avec le 2ème (le HCHO Sensor de grove). Cependant, nous laisserons ces parties pour la prochaine séance.

Photo montage

Séance 5 -05/03/2024

Lors de cette séance, nous nous sommes séparés en 2 groupes : un qui s'occupait du codage de l'Arduino et des différents capteurs, et un autre du cahier des charges de notre éventuel ballon.

Caractérisation du détecteur HCHO

Ce capteur détecte plusieurs composés volatils organiques, dont le HCHO. La famille des composés organiques volatils est très vaste : on en trouve en facilement dans l'atmosphère, mais la plupart ont des effets avérés sur la santé. Ils se caractérisent par un point d'ébullition très bas, et s'évaporent (ou se subliment) facilement. Le HCHO, autrement dit le formaldéhyde, est un bactéricide en petite quantité, mais peut devenir dangereux pour la santé si sa concentration dans l'air augmente. On peut en trouver dans différentes industrie, mais aussi dans un intérieur pas suffisamment aéré : c'est un des problèmes majeures de pollution d'intérieurs (nocive à partir de 1 ppm).

Nous pensions tester le capteur au fablab de chimie, en faisant varier les concentration de COV quelconques : si la valeur d'HCHO qu'il nous renvoie varie en faisant varier la concentrations des COV, alors on devra prendre ce module comme un détecteur de COV et non juste de HCHO.

Voici le wiki du capteur HCHO : Grove - HCHO Sensor | Seeed Studio Wiki

Nous avons rajouté un capteur : le détecteur de flammes de Gotronics. FONCTIONNEMENT detecteur infrarouge

Alors, pour ce module, nous avons bien ris ! Il détecte bien la présence d'une flamme grâce aux infrarouges qu'elle émet, cependant, il détecte aussi le Soleil comme une flamme ! Nous devons augmenter la sensibilité du capteur, afin que notre seuil différencie une flamme du Soleil lui-même (s'ils renvoient des valeurs différentes...).

On remarque que plus le capteur reçoit d'infrarouges, plus la valeurs qu'il renvoie est petite.

Voici le PDF explicatif du module détecteur de flamme (et d'autres) de Gotronics à la page 7 : gotronic.fr

Ecran : Grove - 16*2 LCD, par seed studio

Nous n'avons pour l'instant que pris ce module dans notre boîte. Nous nous laisserons le temps de la prochaine séance pour l'étudier. On compte afficher les valeur de notre "super capteur" sur cette écran en temps réel.

Détecteur CO, et autres : Grove - Gas sensor(MQ3)

Pour ce module, il y a besoin de vapeur d'alcool pour l'étalonnage. Nous ne pensons donc pas le garder...

On a pour projet de tester chaque capteur avec un gaz que lui seul peut détecter, ce que nous ferons surement à la prochaine séance.

Voici une photographie légendée de notre montage

Photo graphique que nous renvoie

En parallèle, pour ce qui est du ballon, on a :

• Il est composé de fuseaux, une documentation approfondie est requise.
• Il 

Voici une photographie légendée de notre montage

Séance 6 -12/03/2024

Au début de cette séance, on étudie le Multichannel gas sensor :

En ne faisant qu'exécuter le code test, on s'est heurté à un problème : la DEL s'allumait bel et bien en fonction du capteur, mais aucune valeur ne s'affichait dans le "print Monitor" de l'application Arduino. En effet, ce capteur est habituellement utilisé avec un autre module, qui réalise certaines fonctions du codage à la place de celui-ci : sur le code, il manquait la fonction "serial.print();" car il doit être couplé à un écran, et que les valeurs devaient s'afficher sur celui-ci et non le Serial Monitor.

Notre code se résume à la somme des codes de références avec quelques modifications (les bons output et input, quelques modifications pour afficher les valeurs sur le serial moniteur, avec une petite mise en page) et à l'ajout de seuils (pour faire bipper le buzzer et clignoter la DEL au dessus ou en dessous d'une certaine valeur)

Voici ce qu'il nous renvoie :

code

Ecran problème pour l'affichage : on peut seulement afficher des dessins pas des fonctions qui s'actualisent en temps réel. Pour faire ça, on devrait recoder chaque pixel de l'écran, ou alors retrouver quelqu'un qui l'a fait.

On projette de tout fixer tout sur plancheplanche. :On

Diamèdonc en parallèle déterminé le diamètre des vis fixationà utiliser pour les fixations :

• 2mm : HCHO Sensor ; multichannel gas sensor V2.0 ; Buzzer actif ; Triple color E-Ink Display

• 3mm : Arduino ; Laser PM2.5 Sensor

• 4mm : déDétecteur de flammes

La breadboard quant à elle a un sticker en dessous qui permet de la coller quelque part.

Il nous reste des diamètres de capteurs à identifier. 

Projets individuels

Les projets individuels sont de 2 types : une gravure/découpe laser sur une planche de 30*30cm, et une impression 3D de 15*15*15cm^3.

Le fichier que la découpeuse laser lis est une image vectorielle

Ainsi, chaque personne de ce groupe documentera ses projets personnels

$fn=100;

module htt(){
    difference(){
        translate([0,0,1.005])
            sphere(0.51);
        translate([-1.0,-1.0,0])
            cube([2.0, 2.0, 1.0]);
    }
}

htt();

module bst(){
    minkowski(){
        cylinder(01.0,0.25,0.5);
        sphere(0.01);
    }
    translate([0,0,0.025])
       sphere(0.26);       
}

bst();



module sgm2(){
translate([0, 0, 0])
   rotate_extrude(angle=120, convexity=10)
       translate([0.6, 0]) circle(0.075);
}


module tcl2(){
    rotate([90,150,90]){
        translate([-1.0,0.2,0]){
            sgm2();
            translate([-0.575,01.0526,0]){
                rotate([0,0,180]){
                    sgm2();
                }
            }
            rotate([180,180,0]){
            translate([-1.0, 0, 0])
                    rotate_extrude(angle=50, convexity=10)
                        translate([0.4, 0]) circle(0.075);
            }
            translate([-1.175,1.0526,0])
                sphere(0.075);
            
        }
    }
}


module tcl8(){
    tcl2();
    rotate([0,0,45])
        tcl2();
    rotate([0,0,90])
        tcl2();
    rotate([0,0,135])
        tcl2();
    rotate([0,0,180])
        tcl2();
}

tcl8();
mirror([1,0,0]) tcl8();



module aa(){
    sphere(0.075);
    cylinder(0.2,0.075,0.075);
    translate([0,0,0.2])
        sphere(0.075);
}

module bb(){
    difference(){
        aa();
    translate([0.05,-0.1,-0.11])
        cube(4);
    }
}

module eye0(){
    bb();
    translate([0.05,0,0.1]){
        resize([0.055,0.055,0.15]) sphere(1);
    }
}

module eye(){
    translate([0.45,-0.2,0.9])
        eye0();
    translate([0.45,0.2,0.9])
        eye0();
}

eye();