Izabela Grubicka¶

Je suis une étudiante en L1 de Sciences pour l'ingénieur à l'Université de Bordeaux et j'ai réalisé un stage de 4 semaines de 22/06 à 17/07 au fablab Coh@bit.

• Contenu
• Izabela Grubicka
  • Projets FreeCAD
    • Dé à jouer
    • Dé à jouer à 20 faces
  • Projet KiCAD
    • Feu tricolore
  • Armoire de séchage pour filament d’impression 3D
  • Impression 3D des éléments
    • Équerre triangulaire + test de résistance
      • Charnière
    • Production d'un armoire
      • Modèle en FreeCAD
      • Liste du matériel
    • Connexion des capteurs
      • Test de capteur IR
      • Câblage de capteurs de poids
      • Ajout des capteurs IR
      • Câblage de lecteurs NFC
      • Test de lecteur NFC
      • Test de capteur de poids
      • Liens vers les sites
    • Prochains étapes

Projets FreeCAD¶

Dé à jouer¶

Dé modelisé en FreeCAD (de_a_jouer.FCStd) avec l'aide du tutoriel dé	Dé imprimé en PLA avec Bambu Lab P1S en 15min

Dé à jouer à 20 faces¶

Icosaèdre fait en FreeCAD avec tutoriel	Modele de dé à 20 faces (icosahedron.FCStd)	Dé imprimé en PLA avec Bambu Lab P1S en 20min46s avec 0,85m de filament

Le modèle peut être améliorer, les espaces entre les chiffres étaient parfois insuffisantes.

Projet KiCAD¶

Feu tricolore¶

Schéma des composants fait en KiCAD à l'aide de tutoriel	Schéma de la carte PCB	Vue en 3D de la carte PCB

Armoire de séchage pour filament d’impression 3D¶

J'ai rejoint le projet au moment du début de la phase de conception d'un prototype d'armoire.

Impression 3D des éléments¶

Équerre triangulaire + test de résistance¶

On a commencé avec une équerre. On a décidé de l'imprimer sur la pointe pour qu'elle soit le plus durable, mais le modèle a glissé sur le plateau et c'était impossible de terminer l'impression. Pour quand même pouvoir vérifier le modèle on l'a imprimé sur le côté. On l'a visé au bois et vérifier comment elle va se déformer si on tire les planches.
On a enfin reussi à imprimer l'équerre sur la pointe, mais, probablement à cause des petits mouvements du modèle pendant l'impression, la surface n'était pas lisse. On a decidé alors d’imprimer toutes les équerres sur le côté.

L'équerre imprimée sur le côté en PLA avec Bambu Lab P1S en 43 min	L'équerre visée aux planches de bois	L'équerre brisée après le test de résistance	L'équerre impriméé sur la pointe

Charnière¶

J'ai modélisé une charnière dans FreeCAD (charniere.FCStd) et je l'ai imprimé en 3D.

Modèle d'une charnière	Charniere imprimée en PLA avec Bambu Lab X1 en 21min23s avec 1,96m du filament

Production d'un armoire¶

Modèle en FreeCAD¶

J'ai modifié le modèle de l'armoire sur FreeCAD avec des nouvelles dimensions afin qu'elles correspondent aux matériaux dont on dispose. J'ai fait un plan de toutes les parois d'un armoire (plans_armoire_2d.pdf) avec un template créé pour réutilisation de toutes les personnes du fablab (A3_LandscapeTD_Fablab_fr.svg) afin de découper correctement les planches.
J'ai ajouté tous les supports dans le CAD pour bien finaliser le modèle de l'armoire avant le début de la construction.
Après, j'ai intégré tous les éléments qui permettront de contrôler l'état des bobines. Pour détecter le moment où une bobine est déposée sur l'étagère, des capteurs IR ont été ajoutés au modèle. Ensuite, pour identifier précisément de quelle bobine il s'agit, des lecteurs NFC ont été intégrés afin de scanner les étiquettes sur les bobines. Pour permettre la pesée des bobines, des capteurs de poids (les jauges de contrainte) ont été ajoutés, deux par niveau. On va voir le poids total des articles présents sur une étagère donnée et le poids de chaque bobine sera enregistré au moment où elle est déposée sur l'étagère. Tous les modelés que je n'ai pas modélisé moi-même (notamment les capteurs) étaient pris d'un site grabcad.

Modèle d'armoire (armoire.FCStd)	Lecteur NFC, capteur IR et capteur de poids	Supports pour les barres et l'équerre en forme de L

Pour apprendre comment correctement utiliser les vis avec le plastic, j'ai regardé une video qui mentionnait un site pour calculer la bonne taille des trous des vis dans plastic.

Liste du matériel¶

liste_materiel.ods

La base de l'armoire:

L’électronique:

Les vis

D'autres:

À imprimer:

Connexion des capteurs¶

Test de capteur IR¶

J'ai fait un test avec un capteur IR afin de voir s'il va fonctionner avec des bobines. J'ai vérifié que le capteur détecte correctement la présence des bobines blanches comme les noires. J'ai suivi le montage proposé sur le site.

Voicile code :le code :

const int irSensorPin = 18;
const int ledPin = 19;

void setup() 
{
  pinMode(irSensorPin, INPUT);
  pinMode(ledPin, OUTPUT);
  Serial.begin(115200);
}

void loop() 
{
  int sensorValue = digitalRead(irSensorPin);
  if (sensorValue == LOW) 
  {
    digitalWrite(ledPin, HIGH);
    Serial.println("Object Detected: LED ON");
  } 
  else 
  {
    digitalWrite(ledPin, LOW);
    Serial.println("No Object: LED OFF");
  }
  delay(100);
}

Montage pour vérifier le fonctionnement de capteur IR avec les bobines

Câblage de capteurs de poids¶

On utilise 10 capteurs de poids dans l'armoire, on a besoin de hx711 pour chacun d'eux. J'ai vérifié si c'est possible de brancher tout ça sur un seul microcontrôleur (ESP32-WROOM-32) et a priori le montage devrais fonctionner. J'ai connecté toutes les sorties SCK des hx711 sur un pin (GPIO13).

Schéma de montage des capteurs de poids

Ajout des capteurs IR¶

J'ai refait le câblage proposé par Lucas Tirand qui a travaillé sur ce projet avant, en ajoutant le capteur IR. Je voulait utiliser son code pour vérifier mon montage et rajouter le code pour les capteurs, mais j'ai rencontré des difficultés car il n'a pas préciser les bibliothèques qu'il a téléchargé. J'ai ajouté les liens vers celles que j'ai enfin trouvé dans le code.

Voicile code :le code :

#include <DHT.h>                  //https://github.com/adafruit/DHT-sensor-library by Tony DiCola for Adafruit Industries + https://github.com/adafruit/Adafruit_Sensor
#include <Wire.h>                 //https://github.com/adafruit/TinyWireM
#include <LiquidCrystal_I2C.h>    //https://github.com/johnrickman/LiquidCrystal_I2C
#include <PID_v1_bc.h>            //https://github.com/drf5n/Arduino-PID-Library by David Forrest and Brett Beauregard

#define brocheDeBranchementDHT 4  // Le DHT22 est branché sur le pin 4
#define typeDeDHT DHT22
DHT dht(brocheDeBranchementDHT, typeDeDHT);

int fanPin = 18;  // Le ventilateur est branché sur le pin 18
int irSensorPin = 17; // Le capteur IR est branché sur le pin 17

LiquidCrystal_I2C lcd(0x27, 16, 2);  // Le LCD peut afficher 16 caractères par ligne sur 2 lignes

// Définition du caractère "°" sur le LCD (tableau 5x8 en binaire)
byte Degres[] = {
  B00111,
  B00101,
  B00111,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000
};

// Variables pour gestion du temps
unsigned long dernierMajDHT = 0;           // dernier moment où le DHT a été lu
const unsigned long IntervalleDHT = 2000;  // Intervalle de lecture DHT en millisecondes

unsigned long dernierMajPID = 0;          // dernier moment où le PID a été lu
const unsigned long IntervallePID = 300;  // Intervalle de lecture PID en millisecondes

// Variable PID
double Setpoint = 50;  // Humidité ciblée
double Input;
double Output;

double Kp = 1.5;   // Proportionnel
double Ki = 1;  // Intégral
double Kd = 0.16;  // Dérivé

PID pid(&Input, &Output, &Setpoint, Kp, Ki, Kd, REVERSE);

void setup() {

  pinMode(fanPin, OUTPUT);
  pinMode(irSensorPin, INPUT);

  Wire.begin(21, 22);  // SDA = 21, SCL = 22 (pins par défaut du LCD sur un ESP32)

  lcd.init();
  lcd.backlight();
  lcd.createChar(0, Degres);  // Création du caractère degrés
  lcd.clear();

  // Moniteur série
  Serial.begin(115200);
  dht.begin();

  pid.SetMode(AUTOMATIC);
  pid.SetOutputLimits(0, 255);  // PMW correspond à une valeur entre 0 et 255
}

void loop() {

  unsigned long millisActuels = millis();

  // Lecture DHT toutes les 2 sec
  if (millisActuels - dernierMajDHT >= IntervalleDHT) {
    dernierMajDHT = millisActuels;

    // Lecture des données
    float tauxHumidite = dht.readHumidity();        // Lecture du taux d'humidité (en %)
    float tauxTemperature = dht.readTemperature();  // Lecture de la température (en °C)

    // Vérification des données
    if (!isnan(tauxHumidite) && !isnan(tauxTemperature)) {
      Input = tauxHumidite;

      // Affichage sur le LCD
      lcd.setCursor(3, 0);
      lcd.print(tauxHumidite);
      lcd.print(" %RH");
      lcd.setCursor(4, 1);
      lcd.print(tauxTemperature);
      lcd.print(" ");
      lcd.write(0);
      lcd.print("C");
    }
  }

  // Lecture PID toutes les 300 ms
  if (millisActuels - dernierMajPID >= IntervallePID) {
    dernierMajPID = millisActuels;

    pid.Compute();  // Calcule PID
    analogWrite(fanPin, (int)Output);

    Serial.print("Vitesse du ventilateur : ");
    Serial.println(Output);
  }
}

Montage avec un ventilateur, un DHT22, un LCD et un capteur IR	Schéma de montage avec 2 ventilateurs, un LCD, un DHT22, 10 capteurs IR et une résistance chauffante avec le relais

J'ai vérifié que les capteurs IR fonctionnent branchés au moins sur les pins GPIO4, 5, 12-35 de ESP32-WROOM-32.

Câblage de lecteurs NFC¶

J'ai décidé d'utiliser les lecteurs NFC PN532 qui ont la possibilité de les connecté via I2C, SPI ou UART. J'ai choisi la première option car ça permet de brancher beaucoup de lecteurs sur un seul microcontrôleur (d'après ce que j'ai trouvé, même avec 10 NFC ça devrais marcher (voir lien 6. dans Informations sur le ESP32)). Il y a aussi assez de pins restants sur le ESP32 pour connecter la reste de capteurs IR.

Schéma de montage de 10 lecteurs NFC sur un ESP32

Test de lecteur NFC¶

On a reçu le materiel commandé et j'ai commencé les tests.

J'ai branché le PN532 en I2C à ESP32-WROOM-32 et j'ai reussi à lire le badge de la bobine Bambu Lab.

J'ai obtenu son UID :
0 24 E8 FB 3F 1 0 0 0 82 0 0 0 0 0 29 0 0 0 16 0 0 10 0 0 73 70 69 66 66 73 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 C8 C9 FB 3F 78 56 AD BA 40 0 0 0 34 12 BA AB 34 0 0 0 24 E8 FB 3F 1 0 0 0 3 0 0 0 0 0 3F 0 0 0 1 0 0 10 0 0 63 6F 72 65 64 75 6D 70 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 78 56 AD BA 68 0 0 0 34 12 BA AB 5C 0 0 0 C CA FB 3F C CA FB 3F C CA FB 3F C CA FB 3F 0 0 0 0 24 CA FB 3F FF FF FF FF 24 CA FB 3F 24 CA FB 3F 0 0 0 0 38 CA FB 3F FF FF FF FF 38 CA FB 3F 38 CA FB 3F 1 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 FF FF 3F B3 0 0 0 0 78 56 AD

Bambu Lab RFID Tag Documentation
How To Read Filament RFID Tags for BambuLab AMS
Installation Iceman Fork - Proxmark3 pour suivre la vidéo ?

Tous les lecteurs ont le même adresse donc on doit trouver une manière soit pour le changer, soit pour aiguiller vers un seul PN532 à la fois (multiplexeur I2C permets de brancher jusqu'à 8 lecteurs, on a besoin de 10 ; un moyen d'allumer qu'un seul lecteur lorsque cela est nécessaire ?).
Sinon on peut utiliser le protocole SPI au lieu de I2C.

PN532 data sheet
PN532 - i2C address control
Changing I2C Address of Sensors
PN532 address changing

J'ai essayé de changer l'adresse I2C mais je n'ai pas reussi. Voicile code :le code :

//https://randomnerdtutorials.com/esp32-i2c-communication-arduino-ide/
//https://forum.arduino.cc/t/changing-i2c-address-of-sensors/910535

#include <Wire.h>

void setup() {
  Wire.begin();
  Serial.begin(115200);
  Serial.println("\nI2C Scanner");
}

void loop() {
  byte error, address;
  int nDevices;
  Serial.println("Scanning...");
  nDevices = 0;
  for(address = 1; address < 127; address++ ) {
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
    if (error == 0) {
      Serial.print("I2C device found at address 0x");
      if (address<16) {
        Serial.print("0");
      }
      Serial.println(address,HEX);
      nDevices++;
    }
    else if (error==4) {
      Serial.print("Unknow error at address 0x");
      if (address<16) {
        Serial.print("0");
      }
      Serial.println(address,HEX);
    }    
  }
  if (nDevices == 0) {
    Serial.println("No I2C devices found\n");
  }
  else {
    Serial.println("done\n");
  }
  delay(3000);
  int error2 = Wire.endTransmission();
  if( error2 != 0)
  {
    Serial.println( "The sensor is not at 0x24");
  }
  else
  {
    Serial.println( "The sensor is found, changing I2C address");
    Wire.beginTransmission( 0x24);
    Wire.write( 0x53);  // password register
    Wire.write( 0xAA);  // password
    Wire.endTransmission();

    delay(10);    // not described somewhere, just for safety

    Wire.beginTransmission( 0x24);
    Wire.write( 0x00);  // I2C address register
    Wire.write( 0x50 << 1);  // new I2C address
    Wire.endTransmission();
  }  
}

Test de capteur de poids¶

Pour tester ce capteur, j'ai d'abord dû souder des composants sur le module HX711 ; j'ai donc commencé par maîtriser ça avant de passer au soudage final sur l'amplificateur.

Ensuite, j'ai constuit une balance, j'ai suivi le code proposé sur le site, mais j'ai changé rtc_clk_cpu_freq_to_config(RTC_CPU_FREQ_80M, &config); à rtc_clk_cpu_freq_mhz_to_config(RTC_XTAL_FREQ_40M, &config);, parce que sinon, un erreur était affiché.

Voicile code pour calibrer la balance:le code pour calibrer la balance:

#include <Arduino.h>
#include "soc/rtc.h" 
#include "HX711.h" //HX711 Arduino Library by Bogdan Necula

const int LOADCELL_DOUT_PIN = 16;
const int LOADCELL_SCK_PIN = 4;

HX711 scale;

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

  rtc_cpu_freq_config_t config;
  rtc_clk_cpu_freq_get_config(&config);
  rtc_clk_cpu_freq_mhz_to_config(RTC_XTAL_FREQ_40M, &config);
  rtc_clk_cpu_freq_set_config_fast(&config);

  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
}

void loop() {

  if (scale.is_ready()) {
    scale.set_scale();    
    Serial.println("Tare... remove any weights from the scale.");
    delay(5000);
    scale.tare();
    Serial.println("Tare done...");
    Serial.print("Place a known weight on the scale...");
    delay(5000);
    long reading = scale.get_units(10);
    Serial.print("Result: ");
    Serial.println(reading);
  } 
  else {
    Serial.println("HX711 not found.");
  }
  delay(1000);
}

J'ai obtenu 87779 comme résultat et donc le facteur de calibration dans mon cas c'est 87779÷225,7 = 388,9189

J'ai vérifié le poids d'un objet pour calculer le facteur de calibration et comparer le résultat final montrer par la balance

Liens vers les sites¶

1. ESP32 Pinout Reference
2. ESP32 with Load Cell and HX711 Amplifier
3. PN532 NFC Module with ESP32
4. ESP32 I2C Communication
5. PWM Fan with ESP32
6. ESP32 I2C Multiple Sensors

1. How a relay works?
2. Make Your Own Temperature Controller
3. Drying filament
4. Armoires de séchage de verrerie - pour choisir la puissance de séchage
5. Tutorial PCF8574
6. Tutorial Multiplexeur TCA9548A
7. Power Switch
8. Utilisation de PN532

Prochains étapes¶

1. Essayer de minimaliser le nombre de microcontrôleurs utilisés (est-ce que c'est possible de brancher tout sur le Raspberry Pi ?) -> PCF8574, UDN2982, TCA9548A
2. Ajouter un interupteur pour pouvoir éteindre l'alimentation
3. Vérifier le fonctionnement de capteur de poids
4. Vérifier le fonctionnement de lecteur NFC - déjà fait
5. Brancher plusieurs NFC sur les mêmes pins I2C
6. Vérifier si les lecteurs sont vraiment compatible avec les tags sur les bobines Bambu Lab - déjà fait
7. Décoder les informations sur les tags des bobines Bambu Lab
8. Ajouter les tags sur les autres bobines
9. Ajouter 10 capteurs IR au montage de 10 NFC, vérifier le fonctionnement
10. Vérifier si c'est possible pour les capteurs de poids de fonctionner sur un même SCK
11. Brancher 10 capteurs de poids sur le même ESP32 et voir si ça marche
12. Imprimer les parois entre les bobines et vérifier si c'est possible de mettre les capteurs dedans
13. Construire un seul étage d'armoire
14. Voir si les capteurs de poids pèsent correctement les bobines
15. Voir si les lecteurs NFC détectent les tags quand on tourne la bobine
16. Vérifier si les supports barre seront suffisants pour tenir les étages
17. Vérifier si c'est vraiment possible de mettre 4 bobines par étage avec les parois
18. Décider où placer le DHT22 (tester si sa position change beaucoup les mesures)
19. Prévoir la position des fils (faire des trous / des supports sur les planches)
20. Construire l'armoire complet
21. Vérifier comment fonctionnent la résistance chauffante et si les ventilateurs changent de la vitesse quand l'humidité varie
22. Ajouter un Raspberry Pi pour contrôler les microcontrôleurs et l'écran tactile
23. Écrire le code pour contrôler le fonctionnement de l'armoire