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.

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

Séance 4 -27/02/2024

C'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 pensons y aller doucement en plusieurs é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 gaz.

https://wiki.seeedstudio.com/Grove-Laser_PM2.5_Sensor-HM3301/#software

Voici la bibliothèque qui permet au capteur de communiquer à l'Arduino.

https://wiki.seeedstudio.com/How_to_install_Arduino_Library/

Voici le code basique pour faire fonctionner le capteur. 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);
}

Avant de tester ce code et notre capteur, nous devons d'abord comprendre quelles sont les données que mesures notre capteur :

- 

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