Groupe A2 doigts de réussir

• Objectifs du FabLab : 

Le premier FabLab fut créé au MIT par Neil Gershenfeld en lien avec son cours "How to make (almost) anything". "Fab" correspond à fabrication numérique et "Lab" à laboratoire de prototypage. Son objectif était de proposer aux étudiants un espace ouvert leur permettant de donner vie à leurs projets scientifiques. Depuis, un réseau international dans le monde entier à été développé, le FabLab de Sorbonne Université en faisant partie. Pour prendre part à ce réseau, plusieurs conditions doivent être respectées, notamment la présence de certaines machines.

• Outils et machines :

On retrouve ainsi au FabLab parmi tant d'autres machines:

- des imprimantes 3D

- des découpeuses laser (pour le plastique et bois) et à eau (pour le métal)

- des fraiseuses électroniques, ...

Il y a aussi des salles réservées à l'électronique (soudure) ou encore le travail du bois, un espace bibliothèque, un espace pédagogique, et des tables et tableaux blancs disponibles pour travailler en groupe. Des outils et composants électroniques sont également à disposition. 

• Documentation :

Une des valeurs principales du FabLab est le partage, c'est pourquoi il est recommandé de travailler en groupe mais surtout il est important de veiller à la reproductibilité des projets et expériences réalisés par tous, via la documentation sur la plateforme Wiki. Il est obligatoire de fournir un résumé de nos travaux. On retrouve ainsi sur le site des tutoriels pour la prise en main des machines et les archives de tous projets, personnels et pédagogiques, réalisés par les étudiants et personnels du FabLab. 

Lors de cette séance, nous avons pu découvrir le Computer-Aided Design, Conception Assistée par Ordinateur (CAO) en Français, qui est une partie importante de l'apprentissage de la FabAcademy. Nous utiliserons des logiciels gratuits, en accord avec les valeurs de partage du FabLab.

• Design 2D :

Le design 2D, pour les découpeuses laser, se fait sur ordinateur via le logiciel Inkscape au FabLab. Ce logiciel permet d'obtenir des fichiers vectoriels au format SVG sans pixellisation ou problèmes de résolution, en créant les images avec des formes géométriques.

Des conventions doivent être absolument respectées pour que les découpeuses laser marchent correctement :

- utiliser des lignes d'1 pixel d'épaisseur

- utiliser des lignes rouges (#FF0000) pour la découpe

- le bleu correspond au marquage (juste des traits)

- utiliser des lignes noires pour la gravure (qui correspond à une puissance plus faible du laser)

Certaines commandes peuvent être utiles également : Ctrl + Maj + F pour déterminer la largeur des traits, clic sur l'objet + Maj + couleur pour changer la couleur du trait par exemple. Il est utile de regarder les tutos disponible sur ce wiki pour s'approprier d'avantage le logiciel. 

Nous nous sommes entraînés au dessin 2D en suivant le modèle donné par l'enseignant : 

Il nous faudra d'ici quelques semaines, dans le cadre de l'UE, faire un dessin 2D sur Inkscape sur une planche 30cm*30cm pour essayer les découpeuses laser par nous même.

• Design 3D :

Nous pouvons utiliser 2 logiciels différents pour le design 3D nécessaire à l'impression 3D : OpenSCAD et FreeCAD. Ces logiciels nous donnent des fichiers 3D au format STL en générant du G-code, correspondant aux déplacements selon x, y et z de la pointe de l'imprimante.

Les éléments suivants peuvent être utiles sur les logiciels : 

- sur OpenSCAD : il faut fermer chaque ligne de code par des points virgules, la fonction F5 pour avoir un aperçu de l’objet généra par le code, F6 pour avoir l’objet final, 

- sur FreeScad : si le logiciel bug, c’est sûrement qu’une tâche en cour n'a pas été terminée/fermée, on peut utiliser la section “Part” pour générer des objets 3D directement et “Sketcher” pour travailler en 2D avant de transformer le dessin en objet 3D.

Nous pouvons chercher sur Internet “nom du logiciel + cheatsheet” pour de l’aide sur les commandes

Nous nous sommes aussi entraînés au dessin 3D en suivant les modèles donnés par l'enseignant : 

Il nous faudra d'ici quelques semaines, dans le cadre de l'UE, faire une modélisation 3D sur un de ces deux logiciels dans des dimensions 15cm*15cm*15cm pour essayer les imprimantes 3D par nous même.

• Démonstration imprimantes 3D et découpeuses laser : 

Avant d’utiliser une machine/un ordinateur des salles de découpe et impression 3D, il faut noter que l’on s’est connecté sur les carnets de log in. 

On utilise du matériau PLA dans les imprimantes 3D, il est disponible en plusieurs couleurs. 2 types d’imprimantes sont disponibles : Pro2 et Pro2Plus. Nous devons choisir la densité de remplissage et la hauteur des couches. Plus les couches sont fines, plus l’impression est longue : c’est pourquoi il nous est conseillé d’utiliser des épaisseurs de 0.4mm et un remplissage de 15 ou 20%. 

Différents rendus des épaisseurs de couches des imprimantes 3D

Les fichiers 3D doivent être ouverts sur IdeaMaker, un autre logiciel, avant d'imprimer sur les machines. Cela nous permet notamment de visualiser les supports automatiquement créés, ainsi que l’aide à l’adhérence et les différentes remplissages grâce à un code couleur. Si l’aperçu nous convient, on télécharge le fichier sur l’imprimante en réseau ou on “exporte sur le disque local” (clé USB) avant de la connecter sur la machine. Il est important de rester pendant les 20 premières minutes de l'impression, car la majorité des problèmes ont lieu au début (fil mal équipé, plateau pas droit, ...). A la fin de l’impression, il faut décoller l’objet du plateau avec une raclette. 

Au Green FabLab est aussi disponible une imprimante 3D à base de résine liquide qui est ensuite solidifiée, ce qui permet des rendus plus lisses. 

Quant aux découpes laser, il ne faut pas monopoliser les machines pendant plus de 30mn, la découpe en soit ne dure que quelques secondes. Si nous sommes les premiers de la journée à utiliser la machine, il faut l'allumer et la laisser se remettre en place avec le capot fermé. Il faut toujours tester sur des chutes au préalable, pour vérifier si c’est la bonne épaisseur de matériau notamment (surtout lorsqu’on découpe des encoches). Nous devons rester pendant tout l'usinage pour prévenir des potentiels départs de feu. Il ne faut pas utiliser son propre matériau à moins d’en connaître précisément la constitution : par exemple, le PVC contient du chlore qui, en brûlant sous le laser, dégage des vapeurs similaires au gaz moutarde. Il faut placer la plaque de matériau à la distance focale de la lentille de la découpeuse à l’aide d’un calpige sur les Speedy100, et placer l’origine du laser sur le dessin (en haut à gauche préférablement). Avant de commencer la découpe, on vérifie que l’on a sélectionné la bonne machine (comme une impression classique sur papier) et le bon matériau dans le logiciel.

Différents rendus de la découpeuse laser sur les différents matériaux disponibles

Les autres découpeuses sont réglées automatiquement sur la bonne distance focale, et le logiciel sur lequel le dessin 2D ne s’ouvre pas sur Inkscape mais Trotec. 

Dans tous les cas, les explications et tutoriels sur l’utilisation des machines sont disponibles en salles d’impression et de découpage, mais aussi sur le Wiki. 

Nous nous sommes concentrés sur l'utilisation de capteurs et la programmation de cartes Arduino. 

Dans Arduino IDE, en branchant le circuit Arduino à l'ordinateur, nous pouvons entrer du code et effectuer des actions. Un exemple de code bien connu est le blink, qui permet de faire clignoter une LED à court intervalle de temps, et nous avons eu l'occasion de le tester. Premièrement, directement sur la LED de la carte Arduino avec le code suivant :

// the setup function runs once when you press reset or power the board
void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);
}

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

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

Sur le site internet GoTronic qui est le fournisseur des capteurs du FabLab, nous pouvons retrouver la majorité des capteurs disponibles ici pour nos projets finaux. 

Nous avons ensuite eu l'occasion de brainstorm sur notre projet. Nous avons penser à faire une machine interactive pour calculer le temps de réaction d'une personne.

avec protocole : type de personnes (sportif ou non, entraîné ou non, femme/hommes) et prédictions, graphiques

temps moyen, capteur sensoriel, led colorées, 

Lors de cette séance, nous avons testé différents capteurs afin de réaliser notre projet. Le capteur qui nous semble le plus adapté est un capteur de vibration (Grove-Vibration Sensor(SW-420)). Nous avons donc essayé de tester le seuil de vibration du capteur pour essayer dans un premier temps de comprendre comment il fonctionne. Pour y parvenir nous avons donc utiliser et modifier le code ci-dessous. Ce code permet de voir si le capteur marche en nous indiquant si les vibrations captées sont basses ou hautes.                                                                                                                                                                        Durant la séance, on a aussi réfléchi à la conception de notre projet et au placement de nos dispositifs. On souhaite avoir 5 "boutons" deux placés au niveau des épaules, deux placés au niveau des hanches et un au niveau du buste. 

pas de library a installer pour ce capteur 

// constants won't change. They're used here to set pin numbers:
const int buttonPin = 2;     // the number of the pushbutton pin
const int buzzer =  3;      // the number of the buzzer pin

// variables will change:
int buttonState = 0;         // variable for reading the pushbutton status

void setup() {
  // initialize the LED pin as an output:
  pinMode(buzzer, OUTPUT);
  // initialize the pushbutton pin as an input:
  pinMode(buttonPin, INPUT);
  Serial.begin(9600);
}

void loop() {
  // read the state of the pushbutton value:
  buttonState = digitalRead(buttonPin);

  // check if the pushbutton is pressed. If it is, the buttonState is HIGH:
  if (buttonState == HIGH) {
    // turn LED on:
    Serial.println("niveau haut");
    delay(500);
  } else {
    // turn LED off:
    Serial.println("niveau bas");
    delay(500);
  }
}

code d'essaie du capteur pour voir à quelle sensibilité le capteur change d'état

modifier le code pour pas utiliser de buzzer -> affiche bien niveau bas/haut dasn ke serial monitor (haut quand secoué)

Nous allons essayer d'autres capteurs pour voir lequel nous semble le plus adapté à notre projet, ayant eu un peu de mal à utiliser le capteur de vibration la semaine dernière. Nous avons pensé au capteur de gestes et à l'accéléromètre.

accéléromètre : installer la library https://github.com/Seeed-Studio/Seeed_Arduino_LIS3DHTR/archive/master.zip , copier le code suivant, mettre en 115200 baud sinon affichage pas des chiffres 

// This example use I2C.
#include "LIS3DHTR.h"
#include <Wire.h>
LIS3DHTR<TwoWire> LIS; //IIC
#define WIRE Wire

void setup()
{
  Serial.begin(115200);
  while (!Serial)
  {
  };
  LIS.begin(WIRE,0x19); //IIC init
  //LIS.begin(0x19);
  LIS.openTemp();  //If ADC3 is used, the temperature detection needs to be turned off.
  //  LIS.closeTemp();//default
  delay(100);
    LIS.setFullScaleRange(LIS3DHTR_RANGE_2G);
  //  LIS.setFullScaleRange(LIS3DHTR_RANGE_4G);
  //  LIS.setFullScaleRange(LIS3DHTR_RANGE_8G);
  //  LIS.setFullScaleRange(LIS3DHTR_RANGE_16G);
  //  LIS.setOutputDataRate(LIS3DHTR_DATARATE_1HZ);
  //  LIS.setOutputDataRate(LIS3DHTR_DATARATE_10HZ);
  //  LIS.setOutputDataRate(LIS3DHTR_DATARATE_25HZ);
  LIS.setOutputDataRate(LIS3DHTR_DATARATE_50HZ);
  //  LIS.setOutputDataRate(LIS3DHTR_DATARATE_100HZ);
  //  LIS.setOutputDataRate(LIS3DHTR_DATARATE_200HZ);
  //  LIS.setOutputDataRate(LIS3DHTR_DATARATE_1_6KHZ);
  //  LIS.setOutputDataRate(LIS3DHTR_DATARATE_5KHZ);
}
void loop()
{
  if (!LIS)
  {
    Serial.println("LIS3DHTR didn't connect.");
    while (1)
      ;
    return;
  }
  //3 axis
    Serial.print("x:"); Serial.print(LIS.getAccelerationX()); Serial.print("  ");
    Serial.print("y:"); Serial.print(LIS.getAccelerationY()); Serial.print("  ");
    Serial.print("z:"); Serial.println(LIS.getAccelerationZ());
delay(1000);  
  //ADC
  //    Serial.print("adc1:"); Serial.println(LIS.readbitADC1());
  //    Serial.print("adc2:"); Serial.println(LIS.readbitADC2());
  //    Serial.print("adc3:"); Serial.println(LIS.readbitADC3());

}

serial plotter pour afficher un graphique

quel système a mettre en place pour indiquer quelle plaque taper

une LED par plaque -> trop encombrant 

utiliser une LED RBG -> entre les plaques, elle s'allume d'une couleur aléatoire parmi celle formatée et chaque plaque est associée à une couleur 

telecharger la library de la led rdg https://github.com/pjpmarques/ChainableLED/releases

schéma des cablages

/* 
 * Example of using the ChainableRGB library for controlling a Grove RGB.
 * This code cycles through all the colors in an uniform way. This is accomplished using a HSL color space. 
 */


#include <ChainableLED.h>

#define NUM_LEDS  5

ChainableLED leds(7, 8, NUM_LEDS);

void setup()
{
  leds.init();
}

float hue = 0.0;
boolean up = true;

void loop()
{
  for (byte i=0; i<NUM_LEDS; i++)
    leds.setColorHSL(i, hue, 1.0, 0.5);
    
  delay(50);
    
  if (up)
    hue+= 0.025;
  else
    hue-= 0.025;
    
  if (hue>=1.0 && up)
    up = false;
  else if (hue<=0.0 && !up)
    up = true;
}

/* 
 * Example of using the ChainableRGB library for controlling a Grove RGB.
 * This code cycles through all the colors in an uniform way. This is accomplished using a HSL color space. 
 */


#include <ChainableLED.h>

#define NUM_LEDS  5

ChainableLED leds(7, 8, NUM_LEDS); //brancher au port D7

void setup()
{
  leds.init();
int Moyenne (int pp,int mes) { // sur 4 mesures
 int total;
 for (byte i=0; i<4; i++) {
 total += mes;
 delay(pp);
 }
 return (total/4) ;
}
byte Ldr;

} 


float hue = 0.0;
boolean go = true;

long num; //variable numéro pour choisir chiffre aléatoire 
byte i=0; // initialise sa valeur à 0

void loop()
{
  for (byte i=0; i<NUM_LEDS; i++)
    leds.setColorHSL(i, hue, 1.0, 0.5);
    
  delay(50);
    
  long f;
  byte i = 0;

  long d;
  byte i = 0;

  if (go)
    unsigned long f=millis(); //mesure du temps (correspond à la fin/quand la plaque est touchée)
    
    int num = random(4); // definir la couleur en choisissant un nombre de 0 à 4
    int hue = num / 5; //lui associer une couleur entre 0 et 1 pour la LED

    unsigned long d=millis(); //mesure le temps au début 

  int t = 0;
  t = f - d; // t le temps de réaction 

  Ldr = Moyenne(10, analogRead(A0)); //... if (Ldr > MaxLight) ...
}

bool go = false; //à mettre avant void setup

//à la fin
if(LIS.getAccelerationZ()<-1.2); //valeur normale à -1 car capteur retourné
go = true;
delay (1000);
go = false;

pour l'accéléromètre 

decoupage des planches

problematique pour la prochaine seance : corriger le code de la led qui marche pas 

differencier les differents ports I2C pour differencier les accelerometre 

// This example use I2C.
#include "LIS3DHTR.h"
#include <Wire.h>
LIS3DHTR<TwoWire> LIS; //IIC
#define WIRE Wire

#include <ChainableLED.h>
#define NUM_LEDS  1
ChainableLED leds(7, 8, NUM_LEDS); //brancher au port D7

void setup() {

    Serial.begin(115200);
  while (!Serial)
  {
  };
  LIS.begin(WIRE,0x19); //IIC init
  //LIS.begin(0x19);
  LIS.openTemp();  //If ADC3 is used, the temperature detection needs to be turned off.
  //  LIS.closeTemp();//default
  delay(100);
    LIS.setFullScaleRange(LIS3DHTR_RANGE_2G);
  //  LIS.setFullScaleRange(LIS3DHTR_RANGE_4G);
  //  LIS.setFullScaleRange(LIS3DHTR_RANGE_8G);
  //  LIS.setFullScaleRange(LIS3DHTR_RANGE_16G);
  //  LIS.setOutputDataRate(LIS3DHTR_DATARATE_1HZ);
  //  LIS.setOutputDataRate(LIS3DHTR_DATARATE_10HZ);
  //  LIS.setOutputDataRate(LIS3DHTR_DATARATE_25HZ);
  LIS.setOutputDataRate(LIS3DHTR_DATARATE_50HZ);
  //  LIS.setOutputDataRate(LIS3DHTR_DATARATE_100HZ);
  //  LIS.setOutputDataRate(LIS3DHTR_DATARATE_200HZ);
  //  LIS.setOutputDataRate(LIS3DHTR_DATARATE_1_6KHZ);
  //  LIS.setOutputDataRate(LIS3DHTR_DATARATE_5KHZ);

}

float hue = 0.0;

unsigned long d;
unsigned long f;
long t = 0;


void loop() {

  leds.init();
  Serial.print("z:"); Serial.println(LIS.getAccelerationZ());

  for (byte i=0; i<NUM_LEDS; i++) {
    leds.setColorHSL(i, hue, 1.0, 0.5);
    hue = 0.7;
    d=millis(); //mesure le temps au début 
  }
  delay(100);

  // Check accelerometers for Z-axis value below -1.2
  if(LIS.getAccelerationZ()<-1.2); { //valeur normale à -1 car capteur retourné
    f=millis(); //mesure du temps (correspond à la fin/quand la plaque est touchée)

    delay(100); 
   t = f - d; // t le temps de réaction
    Serial.print("le temps de réaction est de :  "); Serial.print(t); Serial.println("    ");
  

   for (byte i=0; i<NUM_LEDS; i++) {
    leds.setColorHSL(i, 0.2, 1.0, 0.5);
    }
  }

 delay(3000);

}

le code que le delay de 100ms mais au moins pas de faute