Outils pour utilisateurs
Wiki Arthur, Elise, Manon
Projet: filtration automatisée de nanofossiles calcaires par méthode de tamisation de différentes tailles - paléoclimat du Cénozoïque
Semaine 1 : (28/01)
Explication du projet par Fabrice Minoletti et description des objectifs :
1 - capteur de niveau d'eau
2 - pompe à eau qui s'active lorsque le niveau est trop bas
3 - agitation pour éviter que les coccolithes s'accumulent au fond
4 - usiner les pièces en 3D
Première approche avec Arduino, nous avons essayé d'allumer une LED.
Problème : la LED ne s'allume pas lorsqu'elle est montée sur la breadboard. Si nous la branchons directement sur la carte Arduino UNO, la LED s'allume. Le programme fonctionne donc bien, le problème vient soit du montage, soit de la breadboard.
https://tesseract-it.com/blog/article/comment-allumer-une-led-en-continu-avec-arduino
Semaine 2 : (04/02)
Nous sommes allés à un atelier organisé par Fablab, pour apprendre les bases de la programmation avec Arduino. Après avoir changé de breadboard, la LED s'allume.
Recherche d'un nom pour le projet : Turbococo
Nous choisissons d'utiliser un capteur à eau plutôt que des fils, pour éviter toute contamination/électrolyse avec la solution de coccolithes. Recherche d'un montage, d'un code Arduino et d'un système de fixation du capteur à eau sur le tube. Nous ne pouvons pas tester le capteur car il manque une partie (non-contact liquid level sensor adapter). [Passage de la commande auprès de Pierre]
https://media.digikey.com/pdf/Data%20Sheets/DFRobot%20PDFs/SEN0204_Web.pdf
Semaine 3 : (11/02)
Après avoir reçu un nouveau capteur, on essaie de détecter le niveau de l’eau dans le tube.
Problème : réussir à fixer le capteur au verre sans qu’il y ait d’interférences. On a d’abord essayé avec une élastique en tissu mais on s’est rendu compte que l’élastique était trop épais, trop grand, et qu'il absorbait l’eau (gêne les mesures).
On a remarqué que le capteur détecte le niveau d’eau sans programme Arduino. L’objectif est donc de mettre au point un programme qui stocke l'information “eau détectée/ou non”. En ajoutant une LED au montage, on fait en sorte que le courant passe (la LED s'allume) lorsque le niveau d'eau est “bas” (l’eau n'est pas détectée).
Problème : la LED reste toujours allumée quelque soit le niveau d'eau. On a trouvé un nouveau programme qui fait fonctionner le montage correctement.
https://arduino-france.site/capteur-deau/#3
Fabrice est arrivé avec un moteur et une pompe à eau (rsd3k-micropump). Deux possibilités de montage pour la pompe : soit branchée avec 4 tuyaux soit branchée avec 2 tuyaux.
Problème 1 : si on utilise 2 tuyaux, le débit n'est pas continu et il y a des soucis de pression (bulles d’air). On utilise donc 4 tuyaux.
Problème 2 : les tuyaux de la pompe ne sont pas stables lorsqu'on les place dans le tube, ils bougent et risquent de mettre de l’eau partout. On les a fixés temporairement avec des élastiques. Il faudra trouver une meilleure solution.
Problème 3 : il y a une fuite lorsque le tube est rempli, entre le pas de visse du verre et le bouchon du bas. Il faudra essayé de mettre un joint. En attendant, on place un bol sous le tube pour ne pas mouiller les fils.
Nécessité d'un 2e capteur à placer en haut du tube pour détecter le niveau d’eau maximal à ne pas dépasser. [Passage de la commande auprès de Pierre]
Semaine 4 : (18/02)
Pour résoudre le problème de fuite entre le pas de visse et le bouchon, nous utilisons un joint plat circulaire. Le diamètre étant un peu petit, le tube continue un peu à fuir. Il faudra réessayer avec un joint plus grand, Fabrice en a sûrement.
Nous avons reçu le 2e capteur à eau. On peut donc chercher un montage et un programme Arduino. Celui qu'on a trouvé correspond bien à ce qu'on recherche mais les montages ne sont pas bien explicités et il faut faire quelques adaptations. On a également récupérer une plaque Arduino UNO plus grande, car le montage utilise de nombreuses sorties.
https://www.electronique-mixte.fr/microcontrolleurs/systeme-automatique-de-pompage-avec-arduino/
Les fils reliés à la pompe sont très fins et courts, on a donc soudé deux nouveaux fils pour les renforcer et les allonger. Il faut ensuite enrouler les soudures dans du ruban adhésif pour éviter que les 2 fils entrent en contact (cela provoquerait un court-circuit)
Pour maintenir les capteurs à eau sur le verre, on a pensé à remplacer les élastiques par une visse que nous allons imprimer en 3D. Nous avons donc pris les cotations. Il faudra aussi modéliser un bouchon à mettre en haut du tube qui permettra de maintenir en place les tuyaux de la pompe et l'hélice pour l'agitation.
Semaine 5 : (25/02)
Nous avons à nouveau utilisé le fer à souder pour renforcer précédentes soudures qui étaient trop fragiles. En parallèle, nous avons continué d'essayé d'adapter le montage et le code Arduino pour faire fonctionner conjointement les capteur à eau, les LED et la pompe. On espère y arriver la fois prochaine.
Nous avons modélisé les pièces 3D qui permettront de fixer les capteurs au tube. Pour cela on utilise Tinkercad.
Problème : on a mis un peu de temps avant de bien prendre le logiciel en main, mais maintenant Tinkercad n'a plus de secret pour nous. Après un 1er essai, on s'est rendu compte que les modèle 3D étaient trop petits : on a confondu cm et mm. On s'est aussi trompé dans la mesure du trou central qui est beaucoup trop grande. Les modèles sont enfin prêts à être imprimés. [Impression 3D lancée par Pierre]
Semaine 6 : (11/03)
On bloque toujours sur le code de la pompe et du moteur à agitation. On est donc allé voir Christian au Fablab et on a repris le montage depuis le début. On a d'abord fait s'allumer les 2 capteurs. On a choisi de brancher les capteurs sur le port analogique de l'Arduino plutôt que sur le digital, car cela nous permet de détecter les variations de valeurs (de 0V à 5V). C'est la meilleure option car avec les oscillations de l’eau pendant l’expérience (dues à l’agitation), les capteurs peuvent avoir du mal à détecter le niveau d'eau, ce qui forcerait le moteur à s'allumer et s'éteindre en permanence. On s’est aussi rendu compte qu’il y avait un interrupteur sur chaque capteur qui permettait d’inverser les valeurs d’entrée-sortie (0v devient 5v et 5v devient 0v). Cela pourrait être utile si nous avons besoin d'inverser le rôle des capteurs. Nous avons mis au point un programme pour les 2 capteurs, mais maintenant on a du mal à ajouter la pompe et le moteur pour l’agitation à notre montage.
Problème : l’Arduino n’est pas faite pour alimenter les moteurs. On utilise donc une carte relais pour pouvoir contrôler le passage du courant (220v/10a-srd-05vdc-sl-c). On est allé voir comment se faisaient les branchements pour cette référence.
http://science-facile.fr/2018/12/relai-220v/10a-srd-05vdc-sl-c.html
Après plusieurs tentatives, on a réussi à faire un programme incluant la pompe et sa carte relais servant d'interrupteur : le courant passe et allume la pompe lorsque le capteur bas s'éteint.
Problème : les capteurs ont du mal à détecter le niveau de l’eau qui est trop transparente. Il faudrait donc la rendre plus trouble ou placer un fond noir derrière le tube ou encore améliorer la résolution de détection des capteurs.
Les modèles que nous avions modéliser pour maintenir les capteurs au tube ne sont pas pratiques et on gaspille de la matière pour rien.
Pierre nous a nous imprimé de nouveaux modèles.
https://dropsu.sorbonne-universite.fr/s/akFwWp8NXYcZYZE?path=%2F
Semaine 7 : (18/03)
Fabrice est venu voir notre montage. Validation et finalisation du système pompe-capteur. Nous avons voulu ajouter un interrupteur pour faciliter la mise en route du système, mais sans succès. La carte relais de la pompe a sûrement grillée. Pour empêcher que les soudures des fils dénudés ne se touchent et éviter les cours-circuits, on utilise des dominos.
Semaine 8 et 9: (25/03 et 01/04)
Nous nous attaquons à l'agitation du système. Fabrice souhaite qu'elle se fasse en 2 temps :
- agitation continue lors de la phase de remplissage (tant que le capteur haut est éteint)
- agitation discontinue lors de la phase de vidage. L'hélice fonctionnera ou non par intervalle de temps prédéfini (tant que capteur bas est allumé)
Niveau programmation, on a très vite réussi à faire tourner le moteur en continu pendant le remplissage.
Le programme pour faire fonctionner le moteur par intervalle de temps est plus complexe. Nous parvenons à faire tourner le moteur pendant le vidage, mais l'intervalle de temps est trop court (2sec puis 1 sec) par rapport à celui défini (5sec).
Semaine 10 : (08/04)
Avec l'aide de Loïc, nous sommes parvenus à écrire le programme final : la pompe et le moteur fonctionnent en continus lors du remplissage et le moteur fonctionne en cycle de 5sec lorsque la pompe est éteinte.
Il manque plus qu'à alléger le montage en raccourcissant les fils.
Semaine 11 : (15/04) 2
On a raccourcit les fils et fait des soudures pour que le montage soit plus aéré. On a changer l'Arduino MEGA en Arduino UNO et enlevé la breadboard qu'on a remplacé par des dominos.
Problème : au moment de lancer le programme, la pompe et le moteur ne fonctionnent pas correctement. Nous ne comprenons pas d'où vient le problème : Arduino, programme, capteurs, pompe, branchements, soudures ?
Semaine 12 : (22/04)
Nous reprenons le montage et ça ne fonctionne toujours pas. On a d'abord pensé que le problème venait des dominos, mais même problème lorsqu'on rebranche tout sur la breadboard. Le problème ne vient pas non plus de l'Arduino car en remettant la carte Arduino MEGA, ça ne fonctionne toujours pas. C'est peut-être lié à d'éventuels court-circuits au niveau des soudures ? Fabrice les a refaite et on a mis de nouveaux fils non coupés. Ça ne fonctionne pas non plus. En utilisant des “Serial.println” dans le programme, on s'est rendu compte que le capteur du Haut était cassé. Pierre nous en a donc commandé un nouveau que nous essaierons la semaine prochaine.
Semaine 13 : (22/04)
Nous avons remplacer le capteur du Haut qui ne fonctionnait plus (il affichait 0,82V) par un nouveau. Nous avons repris le montage pas à pas. - Nous remplaçons la carte Arduino MEGA par la carte Arduino UNO - Nous utilisons des dominos à la place de la breadboard pour simplifier les branchements - Les capteurs haut et bas fonctionnent bien individuellement avec le programme : ils affichent 0V quand il n'y a pas d'eau et 5V quand il y a de l'eau. - La pompe fonctionne lorsqu'on branche l'alimentation. Nous arrivons également à la faire fonctionner conjointement avec les capteurs en utilisant le programme (en marche lorsque le niveau d'eau est sous le capteur bas et éteinte lorsqu'il est au-dessus capteur haut). - Le moteur fonctionne lorsqu'on le branche à l'alimentation.
Problème : tous les composants ne fonctionnent pas lorsqu'ils sont branchés ensemble à l'Arduino. Le programme ne fait pas ce qu'on lui demande et malgré les modifications, on observe soit que : - la pompe s'active et s'éteint toutes les 5 sec une fois que le capteur haut détecte l'eau - le moteur et la pompe fonctionnent en continu quelque soit l'état des capteurs - la carte relais vibre, s'allume et s'éteint constamment (alternance rapide de 0 et de 1)
Avec l'aide de Loïc, nous avons repris le programme depuis le début et trouvé les solutions : - les variables remplissage et chrono n'étaient pas définies au bon endroit, on les a retirées de la boucle void loop - on a précisé les conditions des boucles “if” - on a remplacé les boucles “else” par des boucles “if”
Voici le programme final qui fonctionne :
——————————————————– variables
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
——————————————————– initialisation
void setup() {
Serial.begin(9600); // initialisation de la communication série à 9600 bites par s
pinMode (4, OUTPUT); // borne 4 Arduino reliée à la pompe
pinMode (2, OUTPUT); // borne 2 Arduino reliée au moteur
}
——————————————————- traitement
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(A0); // 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
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
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 :
digitalWrite (4, LOW); // "pas de courant" en sortie 4 : le circuit est fermé dans la carte relais, la pompe fonctionne
digitalWrite (2, LOW); // "pas de courant" en sortie 2 : le circuit est fermé dans la carte relais, le moteur fonctionne
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 :
digitalWrite (4, LOW); // "pas de courant" en sortie 4 : le circuit est fermé dans la carte relais, la pompe fonctionne
digitalWrite (2, LOW); // "pas de courant" en sortie 2 : le circuit est fermé dans la carte relais, le moteur fonctionne
remplissage = 1;
}
if ((voltage1 > 2.5)&(voltage0>2.5)){ // si le capteur HAUT détecte l'eau, alors :
digitalWrite (4, HIGH); // "courant" en sortie 5 : le circuit est ouvert dans la carte relais, la pompe ne fonctionnne pas
digitalWrite (2, HIGH); // "courant" en sortie 2 : le circuit est ouvert dans la carte relais, la moteur ne fonctionne pas
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 :
digitalWrite (2, LOW); // "pas de courant" en sortie 2 : le circuit est fermé dans la carte relais, le moteur fonctionne
digitalWrite (4, HIGH);
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 <= 10) & (chrono > 5)) {// si le chrono est > 5 s, alors :
digitalWrite (2, HIGH);
digitalWrite (4, HIGH); // "courant" en sortie 2 : le circuit est ouvert dans la carte relais, le moteur ne fonctionne pas
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 > 10) { // 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;
}
}
} // ferme void loop
Le montage et le programme fonctionnent correctement : validation par Fabrice. On a commencé à modéliser le montage sur Tinkercad. Il ne reste plus qu'à réduire les câblages, enlever les dominos et les replacer sur la breadboard (Fabrice préfère).
Nous tenons à remercier Fabrice Minoletti de nous avoir encadré et surtout de nous avoir fait confiance tout au long de ce projet. Ce fut un plaisir de travailler avec lui au fils des semaines, et nous mesurons la chance que nous avons eu de goûter à son merveilleux café. Un grand merci à Loïc Labrousse pour la partie programmation sans qui moteur et pompe vibreraient encore aujourd'hui. Merci aussi à Pierre Thery d'avoir été présent chaque semaine et aussi impliqué dans notre projet, notamment pour l'usinage des pièces. Merci à Christian du Fablab qui nous a expliqué les bases du montages et de la programmation.
Nous sommes fières d'être parvenus au bout de ce projet et espérons que Fabrice en aura utilité. Nous avons développé des compétences qui nous seront utiles dans notre poursuite d'étude/future vie professionnelle. Merci encore
Outils de la page
