Projets d'UE 2021-2022

Projets d'UE de l'année scolaire 2021-2022 Les documentations des projets d'UE des années précédentes peuvent être consultés sur l'ancien wiki du Fablab : https://wiki.fablab.sorbonne-universite.fr/wiki/doku.php?id=wiki:projets:projetue crédit photo de couverture : www.hotels-paris-rive-gauche.com

• Projets de l'UE 3SV564 - Écologie Urbaine (Sciences vie)
• Impact de l'ozone sur la croissance des épinards
• Impact de pollution numineuse sur les plantes
• Diversité des micro-organismes de la seine
• Impact des murs végétalisés sur les microparticules atmosphériques
• Influence de polluants atmosphériques sur les communautés bactériennes des sols
• Projets CMI 2022
• Groupe A1 : Sismographe
• Groupe A2 : Débitmètre
• Groupe A3 : Vérification de la loi des gaz parfaits
• Goupe B Binome 1 : Wiki dessin

Projets de l'UE 3SV564 - Écologie Urbaine (Sciences vie)

Impact de l'ozone sur la croissance des épinards

Impact de l'ozone sur la croissance des épinards

ARSELIN Jeanne, ANASTACIO Hugo, LOVINELLO Nicolo, VAILLANT Inès

Résumé

Essai de détermination de l'impact du gaz ozone généré artificiellement sur des semis d'épinards cultivés dans une enceinte fermée. Ce modèle a pour but de reproduire en la simplifiant la problématique de l'augmentation possible de l'ozone atmosphérique en zone péri-urbaine (dûe aux émissions des véhicules ou autres), lieux usuel de grandes cultures visant entre autre à alimenter la ville proche. En isolant d'autres facteurs le paramètre ozone nous cherchons à visualiser un effet sur la croissance et/ou l'état sanitaires de plantes alimentaires.

Réalisation

Impact de pollution numineuse sur les plantes

ARSELIN Jeanne,
ANASTACIO Hugo, 
LOVINELLO Nicolo,
VAILLANT Inès.
Démarches scientifiques et 
application à l’écologie,
LU3SV564, 2021.
L’impact de l’ozone sur la croissance
des épinards
I. Protocole,
II. Résultats,
III. Discussion,
IV. Bibliographie.
Sommaire :
pousse de Spinacia 
oleracea, épinard Géant 
d’hiver
Schéma de 
Lewis de l’O3
1
Protocole :
Générateur d’ozone2
Les 4 serres, 2 ozonées 
et 2 témoins
Vue d’en haut d’une serre 
ozonée, avec des LED
Pots de la serre n°2
Plantes des serres n°1 et 2
Tâche sur une feuille de la 
serre n°1
dessiccateur balance feuilles et racines pesées
Les mesures de la longueur foliaire à l’aide du logiciel Digimizer, serre no
3
Résultats :
p-value=0.4378>0.05 p-value=0.1619>0.05
Présence de tâche selon le traitement, p-value=0.0429
 => effet significatif du traitement / nombre de tâches par plantes
Discussion :
tâche due à l’ozone sur 
une feuille de tabac3 Masse de matière fraîche de la plante entière, des racines, 
de la tige et des feuilles, après 35 jours de traitement.
Barres grises : air filtré ; barres blanches : air ozoné.
* Résultat significatif4
.
Plante modèle 
Arabidopsis thaliana
5
Bibliographie :
Merci de votre attention.

Diversité des micro-organismes de la seine

Diversité des micro-organismes de la Seine

BOURILLON Gregory, SAPOVAL Benjamin, ZGRAJA Violette

Résumé

Détermination de l'impact des variations de la qualité de l'eau (déversements divers, pollution atmosphérique, etc.) proche d'une grande ville (Paris) sur la diversité bactérienne.

Réalisation

Des prélèvements d'eau de la Seine à une profondeur définie sont réalisés en amont de Paris, à Paris même, et en aval de Paris pour essayer de visualiser un éventuel effet sur la diversité bactérienne aquatique. Après estimation du nombre de cellules par dilution sériée les prélèvements sont mis en culture sur un milieu solide peu sélectif et dans des conditions de développement médianes (température) pour permettre à un maximum de micro-organismes de se développer. Les observations régulières prennent en compte les types morphologiques (forme et aspect des colonies + observations microscopique).

Impact des murs végétalisés sur les microparticules atmosphériques

Impact des murs végétalisés sur les microparticules atmosphériques

CHARTIER Gabriel, CHIFFARD Léa, ZHOU Cyril

Résumé

Détermination de l'impact de la présence de murs végétalisés permanents sur la qualité de l'air, en particulier sur la variation des niveaux de particules fines (<10µm), dans les rues d'une grande zone urbaine (Paris).

Réalisation

Les mesures in-situ étant soumises à de nombreuses contraintes en fonctions des conditions locales (présence de murs végétalisés, exposition lumineuse, largeur de rue, circulation d'air) et des heures de la journée, nous avons souhaité prélevé (piégeage) l'air ambiant dans des récipients pour réaliser les analyses au GreenLab. Nous avons modélisé des murs végétaux en espace clôt aux paramètres contrôlés, et mesuré l'évolution du taux de particules fines au moyen d'un montage Arduino/capteur de particules SDS011.

Influence de polluants atmosphériques sur les communautés bactériennes des sols

JAMONT Alizée, NORMAND Maëliss, PENAGER Christelle, VERGER Marie-Ornélia

Résumé

Détermination de l'impact de la pollution atmosphérique, en particulier les particules fines et l'ozone, en milieu très urbanisé (Paris) sur la constitution de la communauté bactérienne du sol (diversité et abondance).

Réalisation

Les mesures atmosphériques ont été réalisées in-situ au moyen de capteurs liés à une plateforme Arduino :
-capteur de particules SDS011
-capteur d'ozone

Des carottages de sol dans 9 parcs et jardins parisiens ont été réalisés en parallèle à faible profondeur avant mise en culture pour analyse microbiologique sur milieu peu sélectif (LB) au GreenLab. Les colonies développées ont été observées du point de vue morphologique, quantitatif et par détermination des grands types bactériens au moyen de réalisation d'états frais sur lame sous microscope.

Impact de la pollution atmosphérique sur la comm

Projets CMI 2022

Groupe A1 : Sismographe

Projet Fablab

Membres du groupe

Issar, Yiwei, Christine, Ambre

Cours n°1 (25/01/22)

Idées

Durant cette première séance, nous prenons le temps de réfléchir et d'étudier différentes idées possibles de projet. Nous en retenons deux :

* Sismographe : objet qui peut mesurer les vibrations ou les secousses d'une surface

* Radar : objet qui mesurer la distance entre deux plans

Cependant, nous opterons pour le sismographe car l'élaboration de ce projet fera appel à plus de connaissances et de compétences électroniques que le radar qui fonctionne principalement par ondes ultra-sonores.

Cours n°2 (01/02/22)

Objectif

Le but de cette séance était de faire une prise en main des logiciels Freecad et Inskape. Pour cela nous avons tout d'abord modélisé un cube de 5mm de côté troué sur chaque face avec pour rayon 1mm puis nous avons tracé un carré de côté 5cm avec 4 cercles de rayons 2mm.

Réalisation du cube en 3D sur FreeCAD

Nous avons décidé de suivre ce tutoriel : https://youtu.be/_HEvhclR4-o

Cependant nous avons rencontré énormément de difficultés lors de la manipulation du logiciel.

Notre méthode pour la création du cube était assez différente de la méthode utilisée par le reste de nos camarades. En effet, au lieu de créer dans un premier temps une esquisse sur laquelle nous aurions placé un carré que l'on aurait ensuite transformé d'un plan 2D à un plan 3D, nous avons appliqué une toute autre méthode. Tout d'abord en créant un cube dans lequel nous avions placé un cylindre au centre (plus ou moins) que l'on a par la suite coupé pour pouvoir faire un trou. Néanmoins nous nous sommes rendues compte que cette méthode manquait énormément de précision à cause de l'absence d'esquisse. En recommençant alors plusieurs fois la modélisation nous avons fini par réussir !

Résultats

Réalisation du carré en 2D sur Inkscape

Nous avons tout d'abord tracé un carré rempli en cliquant sur l'icône “créer des rectangles et des carrés”. Nous avons ensuite modifié les dimensions afin d'obtenir des côtés de 50mm. En utilisant la “règle stylo” nous avons tracé les contours du carré afin d'obtenir un carré vide. Puis nous avons effacé le carré rempli. Et pour finir nous avons essayé de placer correctement les cercles de rayon 2mm à l'aide des graduations.

Résultats

Cours n°3 (08/02/22)

Objectif

L'objectif de ce cours était de prendre en main la carte de programmation Arduino.

LED clignotante

Pour commencer nous avons essayé de créer un montage et un programme qui nous permettraient faire clignoter une LED afin de nous familiariser avec la programmation en C.

Liste des composants:

Programme :

Capteur HC-SR04, LED et distances

Nous nous sommes ensuite intéressées au fonctionnement du capteur HC-SR04. Nous avons alors essayé de faire un montage permettant de nous indiquer a quelle distance se trouvait un objet en faisant allumer ou éteindre les LED.

Liste des composants:

Étape Intermédiaire: Fonctionnement du capteur HC-SR04

Nous avons tout d'abord fait fonctionner le capteur HC-SR04.

Montage Final

Nous constatons que plus nous nous éloignons de l'objet, plus il y a de LED qui s'éteignent.

Programme :

Cours n°4 (15/02/22)

Nous allons alors procéder à la création de notre sismographe.

Tout d'abord le sismographe est un appareil qui permet de mesurer les mouvements de la surface de la terre, c'est-à-dire des tremblements de terre ou des tremblements de toute nature.

1 ère étape

Nous faisons la liste des composants nécessaires pour la réalisation de notre sismographe:

2 ème étape

Nous schématisons la construction de notre sismographe. Nous allons utiliser une potence sur laquelle sera accroché notre ressort enroulé autour d'une tige en plastique pour le maintenir stable.

3 ème étape

Nous expérimentons et testons plusieurs constructions possibles de notre sismographe . Par exemple, comment mesurer le courant créé grâce à l'inductance. Pour cela, nous avons enroulé du fil de cuivre autour d'un feutre afin d'obtenir des spires plus ou moins de la même taille et de la même forme. Nous avons ainsi une succession de spires, jouant le rôle de bobine de cuivre. Puis, nous avons pris un multimètre que nous avons connecté à chaque bout de notre fil de cuivre (pour les connecter nous avons enroulé chaque bout du fil à chaque tige en métal des câbles branchés au multimètre). Nous avons ensuite pris plusieurs aimants que nous avons empilés les uns sur les autres afin d'avoir un long aimant pour pouvoir faire un mouvement dans notre bobine de cuivre. Ensuite, nous faisons un mouvement de va-et-vient dans notre bobine avec notre aimant. Cependant nous n'observons aucune variation de courant. En effet, la tension est trop faible pour être mesurée sur notre multimètre.

Cours n°5 (22/02/22)

Durant cette séance nous nous sommes fixées plusieurs tâches à accomplir. Tout d'abord, la construction de notre circuit qui sera connecté à notre carte Arduino, puis la création de notre programme informatique, et pour finir la modélisation de notre bobine à travers le logiciel Freecad.

Construction du circuit

Pour la construction du circuit nous avons décidé de suivre le schéma suivant :

Nous obtenons ceci :

Cependant le circuit étant trop condensé, nous sommes revenues au fablab afin de faire un circuit dont les composants sont plus espacés afin d'éviter que les pattes des résistances se touchent.

Cours n°6 (08/03/22)

Nous avons commencé la séance par fixer des objectifs:

Le cylindre:

Nous avons tout d'abord modélisé le cylindre à l'aide de FreeCad puis nous l'avons converti dans les formats correspondant (stl). Nous l'avons ensuite transféré sur IdeaMaker et converti en document g-doc. Lors de l'impression, l'imprimante a cessé de fonctionner correctement au bout d'un certain temps, nous avons alors demandé de l'aide à un membre du FabLab qui a relancé l'imprimante, l'a purgé et puis nous avons relancé l'impression. Ayant toujours le même problème, nous avons écarté l'hypothèse que ce soit l'imprimante qui ait un problème et nous nous sommes alors penchées sur notre fichier. La personne responsable au fablab a vérifié celui-ci mais n'a rien trouvé d'anormal. Nous avons donc re-modélisé le cylindre de A à Z mais l'impression n'a pas fonctionné tout de même.

Cours n°7 (15/03/22)

Au cours de séance nous avons rencontré plusieurs difficultés.

Tout d'abord nous avons réalisé que notre programme ne fonctionnait pas. En effet, notre objectif était de vérifier que notre amplificateur permettait, par le biais du programme, d'envoyer une tension de sortie supérieure à la tension imposée à l'entrée. Cependant, notre programme nous rendait une tension de sortie inférieure. Nous nous sommes rendues compte que le programme ne faisait que changeait la valeur de tension de sortie par un calcul.

Programme :

Dans un deuxième temps, les imprimantes 3D à disposition ne pouvaient pas imprimer la bobine que nous avons modélisé sur le logiciel FreeCAD. En effet, nous avons testé plusieurs imprimantes mais nous obtenons toujours le même résultat: impossible d'imprimer correctement notre bobine bien que nous ayons vérifié toutes les conditions nécessaires pour. Nous obtenons cette bobine qui présente cependant des impuretés à l'intérieur que nous avons limées.

Ensuite, vient la création de notre structure qui maintiendra notre bobine, les aimants, etc. Nous avons opté pour une structure simple, composée d'un socle de dimension (20x10cm), d'une potence de longueur 20cm, le tout en bois. De plus, nous avons fait une gravure sur une plaque en bois. Puis nous avons assemblé le tout.

Nous sommes ensuite revenues au fablab afin de faire un autre programme Arduino car celui qu'on avait ne faisait pas ce qu'on voulait. Nous obtenons ainsi ceci :

Programme :

Cours n°8 (22/03/22)

On a enroulé du scotch autour des aimants empilés les uns sur les autres, afin de pouvoir enrouler du fil de cuivre autour, créant ainsi notre bobine. Le scotch permet d'isoler notre bobine, évitant tout contact avec les aimants lorsque nous ferons l'induction.

A présent nous commençons à réfléchir à l'esthétique de notre projet. On a réfléchi à la structure d'une boîte permettant de mettre le circuit. Cependant cette idée fut abandonnée afin de se concentrer sur notre circuit qui n'est pas encore fini.

Finalement, pour une question d'ordre pratique, on décide de mesurer les vibrations sur l'axe horizontal. De plus, concernant les aimants, on ne les accrochera pas à une tige comme prévu, mais directement à 2 ressorts.

Nous sommes ensuite revenues au fablab afin d'accrocher nos 2 ressorts. Cependant, pour une raison de praticité nous décidons de n'accrocher qu'un seul ressort, ce qui prendra moins de place.

De plus, sous sommes aussi revenues au fablab plusieurs fois durant cette semaine, afin de faire un circuit et d'imprimer à l'imprimante 3D une nouvelle bobine (plus grande) et la structure finale que nous avons modélisé chez nous à l'aide d'Onshape. En effet, nous décidons de changer de structure pour une question d'esthétique et de praticité. En effet, la breadboard étant aimantée il faut : soit élever notre bobine pour que l'aimant passant à l'intérieur ne soit pas attiré à la breadboard, ou soit il faut mettre une plaque qui va isoler le bas de notre bobine. Nous optons pour cette 2ème idée. Ainsi pour une raison d'esthétique nous décidons de recommencer la structure, mais cette fois-ci nous la ferons à l'imprimante 3D.

Cours n°9 (29/03/22)

Nous avons fait le circuit final. Cependant nous ne l'avions pas fini lors de ce cours, c'est pour cela que nous sommes revenues au fablab afin de terminer notre circuit. Au final nous obtenons ceci :

Liste des composants :

Explication du circuit :

Un amplificateur opérationnel a besoin qu'on lui envoie une tension négative et une tension positive. Cependant la carte Arduino ne peut pas envoyer de tension négative. Ainsi, on doit “annuler” cette tension négative. Pour cela, on fait un pont diviseur de tension avec 2 résistances : peu importe leur valeur du moment que les 2 résistances sont les mêmes : la tension sera ainsi divisée par 2. Nommons nos 2 résistances R1 et R2.

Ainsi comme R1 et R2 sont équivalentes, on peut remplacer R2 par R1. Nous obtenons ainsi que la tension de sortie est égale à la tension d'entrée divisée par 2.

Ici on a pris 2 résistances de 10kΩ. En effet, sans pont diviseur de tension notre signal est centré autour de 0V donc une partie du signal a un voltage négatif. Etant donné qu’avec la carte Arduino on va envoyer une tension de 5V, notre pont diviseur de tension va nous renvoyer 5/2 soit 2.5V, ce qui permettra de décaler notre signal et donc qu’il soit centré autour de 2.5V, ce qui nous permet de ne pas avoir de tension négative.

Amplificateur Opérationnel TL082:

On a ainsi branché :

Notre sismographe ressemble à ceci :

Nous avons ensuite ajouté un ressort sur lequel nous avons collé une vis avec des aimants. La vis permet qu'on ait moins d'aimants sur le ressort, ce qui nous permettra d'avoir une meilleure variation de courant lors de l'induction. De plus, grâce à la vis, les aimants ne sont pas trop proches de la bobine, ils peuvent donc faire un mouvement de va-et-vient en entrant et en sortant de la bobine.

La semaine suivante, nous sommes allées au fablab afin d'effectuer des mesures. Sur le logiciel Arduino, en utilisant “le traceur série” nous obtenons un graphe dont l'amplitude est de 274 bits. Comme notre circuit a été construit de sorte d'obtenir un signal centré autour de 2.5V, et que nous voyons que notre signal est centré autour de 273 bits, nous pouvons ainsi dire que 273 bits correspond à environ 2.5V.

Nous avons secoué notre sismographe 6 fois pour noter les amplitudes lors de vibrations. Nous obtenons différentes amplitudes, allant de 279 bits qui correspond à 2.55V, à 360 bits qui correspond à environ 3.30V.En faisant la moyenne nous obtenons environs 2.77V lorsque notre sismographe subit des vibrations, ce qui nous fait une variation de tension de 0.27V par rapport à la tension lorsque le sismographe est “au repos”.

Voici une démonstration:

Conclusion

Finalement, nous pouvons conclure que notre sismographe fonctionne, les valeurs obtenues sont proportionnelles à l'amplitude des vibrations.

Cependant notre projet présente plusieurs limites:

- Tout d'abord, il manque de précision, nous n'avons malheureusement pas mesurer les incertitudes.

-D'autre part, notre sismographe mesure les ondes sismiques seulement sur l'axe horizontal. Ainsi, nous pourrions prochainement ajouter deux autres bobines, aimants et ressorts afin de récolter des mesures sur tous les axes comme représenté sur le schéma:

- Ensuite, le signal reçu subit également énormément de perturbations causées par le bruit ambiant ce qui nous empêche d’obtenir un signal précis des vibrations étudiées.

Malgré, toutes ces limites il est tout de même possible d'améliorer notre projet. En effet, comme nous l'avons expliqué, il est possible d'ajouter d'autre bobine afin d'étudier les vibration sur tous les axes. Ensuite, pour avoir une idée plus précise sur l'efficacité de notre sismographe nous pouvons utiliser une plateforme vibrante.

Pour finir, malgré les difficultés rencontrées, ce projet Fablab nous a permis de développer des connaissances et des compétences spécifiques dans divers domaines, et sortir de notre zone de confort dans le but de tester de nouvelles idées et méthodes pour surmonter ces épreuves.

Groupe A2 : Débitmètre

Groupe A2

• Alexandre MACAULLY - alexandre.macaully@etu.sorbonne-universite.fr
• Rita SILVA - rita.silva@etu.sorbonne-universite.fr
• Noah SEGONDS-RICHARD - noah.seconds-richard@etu.sorbonne-university.fr
• Guillem JOSEPH - guillem.joseph_planas@etu.sorbonne-universite.fr

Projet Débitmètre
Dans cette page figurent des explications plus détaillées sur le débitmètre.

Semaine du 25 janvier 2022

Semaine du 31 janvier 2022

Lors de cette séance, nous devions nous familiariser avec les logiciels de modélisation 3D (Freecad) et 2D (Inkscape).

Freecad

Nous avions pour objectif de modéliser un cube en 3D de 5mm de coté avec 3 trous centrés de 1mm de rayon. Pour ce faire, nous avons commencé par regarder un tuto, (http://wiki.labaixbidouille.com/index.php/Creation_d%27un_cube_troue_avec_FreeCAD_Francois) afin d’avoir une idée de la marche à suivre pour réaliser notre objectif.

Grâce à ce tuto nous avons pu créer une esquisse d’un carré de 5mm de coté.

Ensuite, grâce à la fonctionnalité « faire une protrusion de l'esquisse sélectionnée » nous avons pu former un cube à partir de l’esquisse précédemment créé.

A partir de cette étape nous avons suivi un second tuto (https://youtu.be/NcvW9L5p6FU) afin de pouvoir trouer notre cube.

Nous avons donc commencé par créer un cylindre grâce à la fonction « créer un cylindre » de la fenêtre « part ».

Afin de créer le trou, nous avons modifié le diamètre du cylindre ainsi que sa position initiale afin de le centrer sur notre cube.

Nous avons ensuite extruder ce cylindre à notre cube afin de créer un trou dans ce dernier en sélectionnant notre cube ainsi notre cylindre en utilisant la fonction « faire un découpage entre deux formes ».

Enfin, nous avons répété cette dernière étape 2 fois de plus en modifiant les coordonnées initiales du cylindre afin d’obtenir le modèle attendu.

Inkscape

Pour cette deuxième partie du travail, nous avons voulu dessiner un carré de 50mm perforé en chacun de ses coins par des cercles de 2mm de rayon chacun.

Première étape : Dessiner un remplissage carré + dimensionnement + positionnement Sur la barre latérale gauche figure une icône en forme de carré. En cliquant dessus, un carré rempli apparaît. Il nous faut conserver uniquement les contours de ce carré. Pour ce faire, nous cliquons sur le polygone, et une interface avec la rubrique « Fond et contour » apparaît. Enfin, il suffit de cliquer sur l’icône en forme de croix pour ne laisser que le contour. Nous colorions ce dernier en rouge. A l’aide de la barre horizontale supérieure, nous fixons Hauteur H et longueur L de notre figure à 50mm. Enfin, nous choisissons de positionner le sommet inférieur droit de notre carré, simplement en fixant les coordonnées x et y à la valeur zéro.

Deuxième étape : Dessiner quatre cercles + dimensionnement + positionnement Sur la barre latérale gauche figure une icône « Dessiner des cercles et des ellipses » avec laquelle nous formons un premier cercle. Nous fixons ses dimensions (hauteur H et longueur L) à 4mm. En effet, H correspond au diamètre vertical, tandis que L correspond au diamètre horizontal. On obtient donc un cercle de 2mm de rayon.

Nous positionnons ce cercle à 1mm du coin inférieur gauche (origine du repère). Nous copions trois fois ce cercle, et nous positionnons les trois copies dans les autres coins du carré, toujours à 1mm de chaque sommet.

Semaine du 7 février 2022

Cette séance nous a permis de prendre en main la carte programmable Arduino.

Faire clignoter une LED

Pour commencer, nous avons essayé de faire clignoter une LED. Pour cela, nous avons branché en série une résistance 220Ω et une LED bleue.

Programme:

Chenillard de LED

Nous avons ensuite réalisé un chenillard de LED, c'est-à-dire plusieurs LED qui clignotent avec un décalage temporel entre 2 LED successives. Le montage est le même que celui de la LED qui clignote, mais répété 3 fois - notre montage étant constitué de 3 LED -

Programme:

Température

Pour ce projet nous avons suivi deux tutoriels: https://www.youtube.com/watch?v=v8Pway-5sFY&list=PL0YfVdOGWSEQCIEZj_-dFsnClqyxqDmA_&index=6 et https://www.youtube.com/watch?v=8s5wY9kljyE&list=PL0YfVdOGWSEQCIEZj_-dFsnClqyxqDmA_&index=9.

Nous avons utilisé le capteur «thermat» et le «1602 display» (l'écran) afin de détecter la température de la salle et ensuite l'afficher sur un écran numérique.

Nous avons le montage final suivant (capteur + ecran):

Pour plus de détails sur le montage vous pouvez regarder les liens, le premier concernant l'écran et le deuxième le capteur de température.

Programme:

Remarques: Nous avons eu des problèmes pour afficher une température qui nous semblait acceptable pour la salle du Fablab (entre 18ºC et 23ºC). Après avoir testé les différentes parties de notre montage et du programme nous avons compris que l'erreur était due à la partie du programme concernant la conversion en ºC de la grandeur mesurée par le capteur. En effet, notre capteur ne mesurait pas directement les différences de température. Ainsi, pour afficher une température décente, il nous fallait faire des conversions. Nous n'avons pas réussi à trouver les bons numéros car nous n’avions pas les spécifications du capteur. Mais nous avons constaté que la valeur obtenue par le capteur changeait en faisant varier sa température alentour. Cependant, bien que l’écran affichait une valeur, ce n'était pas la grandeur souhaitée.

Semaine du 14 février 2022

Dans cette séance, nous avons choisi quel sera notre projet. Nous voulons réaliser un débitmètre à l’aide d’un moulin à eau miniature et d’un laser. A l’aide d’une photodiode placée derrière le moulin (lui-même placé entre le laser et la photodiode), nous pourrions acquérir à l’aide de la plaque programmable Arduino le nombre de tours par minute du moulin à eau. Ceci nous permettra de connaître le debit du fluide qui fait tourner le moulin de notre instrument. Nous pourrons potentiellement afficher le résultat sur un écran relié à la plaque Arduino.

Pour ce faire, nous avons commencé par essayer de modéliser notre moulin à eau en 3D sur Freecad. Après quelques recherches, nous sommes parvenus à trouver un moulin pré-modélisé qui correspondait à l’idée que nous en avions. Après quelques petites modifications, nous sommes parvenus à la modélisation finale de notre moulin. A la prochaine séance, nous commencerons à programmer sur la plaque Arduino afin d’effectuer la bonne conversion entre le nombre de tours par minute et le debit. Aussi, nous modéliserons le reste des pièces à imprimer qui joueront un rôle-clé concernant le fonctionnement de notre moulin ; parmi celles-ci, un axe autour autour duquel le moulin devra tourner.

Semaine du 21 février 2022

Au programme:
1) Listing des tâches à effectuer
2) Répartition du travail

Rita et Noah : Pour rappel, il est prévu que le débitmètre fonctionne à l’aide d’une lumière laser pulsée. Cette pulsation doit être obtenue par l’interruption périodique du faisceau laser au contact d’un obstacle opaque. Avec le logiciel FreeCad, Rita et moi avons perforé le moulin non loin de son bord. Le trou effectué permettra, au gré de la rotation du moulin, de générer une pulsation “artificielle” du laser ; tantôt le faisceau passera par le trou, tantôt il sera bloqué par la structure-même du moulin.

Communément : Nous sommes retournés tous ensemble au FabLab dans le courant de l’après-midi afin d’y effectuer notre première impression 3D : celle du moulin lui-même.

La prise en main de l’imprimante 3D n’est pas très compliquée : deux étapes sont requises. Premièrement, il faut posséder le fichier format STL de FreeCad sur une clé USB, qu’il convient ensuite de l’importer sur le logiciel IdeaMaker disponible sur les ordinateurs du FabLab. À l’aide de l’interface du logiciel, il est possible de choisir les paramètres d’impression : épaisseur de couche et robustesse, finitions, position de la pièce à imprimer, utilisation de supports d’impression, visualisation du résultat… . Deuxièmement, il faut exporter la modélisation sur la clé et insérer cette dernière sur le port USB de l’imprimante. L’écran tactile de la machine permet la sélection de la modélisation à imprimer, et de lancer l’opération d’impression.

Photo du 1er modèle de moulin :

Semaine du 8 mars 2022

Des modifications sont à apporter au moulin : le remplissage et le nombre de pales sont trop importants et ne permettent pas de mettre correctement la roue en rotation ni de mesurer le volume d’eau écoulé. Il faut également avancer sur la conception et la réalisation de la structure externe de l’instrument Répartition du travail :
Alexandre et Noah : Modélisation des parois externes du débitmètre.
Rita et Guillem : modification de La structure du moulin.

Modélisation 3D du modèle final du moulin : (cf page annexe pour plus de détails)

Modélisation des parois du débitmètre où il y aura la photodiode et le laser : cavité du moulin

Semaine du 15 mars 2022

Ordre du jour : poursuite de la modélisation 3D des pièces de l’instrument.

Rita et Guillem :modélisation de la partie électronique de notre débitmètre afin que le circuit Arduino soit protégé de l’eau. L’idée est aussi de rendre le débitmètre plus esthétique.

Plafond et paroi de la protection :

Support du circuit électronique :

Alexandre et Noah : modélisation de la base ( “sol” ) de l’instrument. Cette base est constituée en plusieurs parties.
———> Plan incliné : Il s’agit de la pièce à paroi latérale triangulaire.
———> Excavation au pied du plan incliné : Il s’agit d’un creux rectangulaire dont la longueur est égale à la profondeur du plan incliné. Ces deux premières pièces servent à l’évacuation de l’eau.
———> Support : Il correspond au plus gros pavé ; il soutient toute la base de l’instrument.
———> Parois externes : Elles s’apparentent à des pavés fins et très longs, et embrassent une bonne partie du pourtour du support afin de rendre plus solide la structure globale et d’éviter des quelconques décalages.

Semaine du 22 mars 2022

Ordre du jour : récupération des impressions 3D de la semaine passée, lancement des dernières impressions, poursuite du code Arduino.

Code Arduino :
Petite modification dans notre montage électronique analogique : nous n’avons pas de photodiode. Par conséquent, nous devons y substituer une photorésistance. Ceci ne pose pas de contrainte supplémentaire, étant donné que la carte Arduino est dotée de pins d’alimentation ; l’alimentation de la photorésistance s’effectue sans passer par un générateur extérieur. Afin de mesurer notre débit, nous avons besoin de quantifier une durée de rotation.

À l’aide d’un débit connu (certaine force d’écoulement de l’eau) : mesurer durée d’un certain nombre pulsations ( 1 pulsation = 1 éclairement ⇒ faible tension photorésistance OU = 1 “obscurité” ⇒ forte valeur tension photorésistance), et en faire la moyenne. On a ainsi une corrélation entre une valeur déterminée de débit et une durée moyenne de pulsation. Cette corrélation va être utilisée comme étalon. Il suffit alors d’effectuer un produit en croix pour obtenir la valeur actuelle du débit. Quelques précisions : Calcul de la durée moyenne d’une pulsation : le programme effectue la moyenne “instantanée” à chaque nouvelle pulsation. Il accumule la durée des pulsations et calcule une moyenne à chaque nouvelle pulsation. Ceci offre l’avantage d’obtenir un plus ample échantillon de débits, et d’augmenter la précision au cours du temps. L’élément principal du code est la fonction “PulseIn”, ne prenant aucun argument, et renvoyant la durée d’une pulsation.

Modification de la source de lumière :
Nous nous sommes rendus compte que la focalisation du faisceau laser ne facilite pas la détection par la photorésistance. Nous optons plutôt pour une lampe dont le faisceau est bien plus diffus et touche plus facilement la photorésistance.

Débitmètre avec le laser

Débitmètre avec la lampe :

Choix de la source d’eau :
Jusqu’ici, nous n’avions pas de réelle idée quant à la façon dont produire un débit d’eau. Cependant, nous optons pour une jarre que Rita et Guillem ont achetée chez HEMA. Celle-ci va s’avérer très utile pour générer et contrôler un débit d’eau par l’intermédiaire d’un petit robinet. En plus de cela, la jarre n’est pas trop volumineuse et permet son déplacement dans trop de difficultés.

Semaine du 29 mars 2022

Ordre du jour : finalisation du projet et préparation de la soutenance.

Nous choisissons de répartir les tâches :

Alexandre et Guillem : Nous avons finalement décidé de modifier la structure de notre code afin de simplifier le circuit Arduino. En effet, afin d’utiliser la fonction « pulseIn » nous aurions dû utiliser un montage comparateur. Nous avons donc opté pour une structure plus traditionnelle avec des boucles nous permettant de réaliser notre objectif.

Pour plus de détails sur le code, le circuit ainsi que le traitement du signal, cf la page annexe.

Rita et Noah : élaboration de la structure de la soutenance et participation aux tests du débitmètre.

Tous ensemble : nous effectuons une série de tests dans lesquels nous utilisons la jarre pour générer l’écoulement de l’eau. Au gré des rotations du moulin, nous suivons à l’écran de l’ordinateur le nombre de trous illuminés. Nous vérifions les valeurs que l’afficheur numérique présente. Nous rencontrons beaucoup d’erreurs et d’incohérences, que nous parvenons à corriger progressivement. Exemples d’erreurs :
Enfin, nous vous proposons une vidéo de l’ensemble du débitmètre ainsi qu’une seconde démontrant le fonctionnement de l’instrument.

Structure du débitmètre

Fonctionnement du débitmètre

Tâches:
Structure
1. Axe (dimensions, maintien, matériel, conception)
2. Perforation du moulin
3. Positionnement et maintien du laser et de la photodiode
4. Achat d'un recipient a volume connu et délivrant un débit réglable
5. Réglage avec un volume d'eau connu
Hardware et Software
5. Codage arduino, affichage
6. Réalisation du circuit

Modélisation 3D des différentes pièces:

Sur chacune des parois figure une ouverture carrée ainsi qu’une plate-forme rectangulaire accolée à la base de l’ouverture. Ceci permet d’y poser simplement le laser ou la photodiode. Quant aux ouvertures carrées, elles jouent le rôle de communication entre laser et photodiode, puisque nous souhaitons illuminer cette dernière.

Technique utilisée pour la fixation des parois :
La paroi de la lampe et celle de la photodiode s’imbriquent l’une dans l’autre par un système de tenons et de mortaises. Aux deux extrémités de la paroi de la photodiode se trouvent deux “protusions” appelées tenons. Sur celles de la paroi de la photodiode figurent des renfoncements appelés “mortaises” et dont le volume est “complémentaire” à celui des tenons. Nous avons cependant appliqué une différence de diamètre de

1mm entre tenons et mortaises afin de faciliter l’imbrication.
Ainsi, les deux parois font s’aligner les fenêtres carrées et permettent la “communication” du laser et de la photodiode ; le faisceau laser traverse toute la cavité d’une fenêtre à l’autre.

Détails sur la modélisation du plan incliné :
Le plan incliné joue un double rôle : réception et évacuation de l’eau écoulée. Sa technique de conception repose toujours sur un principe de soustraction booléenne. Cependant, quelques étapes supplémentaires sont à prendre en compte. Notre objectif est d’obtenir un trapèze en 3D dont les faces latérales superposables. Ces Chacune constitue un triangle rectangle, dont la hauteur vaut “h”, et la base “L”. Deux angles sont d’intérêt : L’angle droit qui se trouve au sol, et l’angle “alpha” qui se trouve être le plus éloigné. Avec l’outil de soustraction booléenne, il nous faut partir de deux pavés d’égales dimensions, l’un rouge et l’autre noir, et orienter l’un des deux d’un angle “alpha”. Or, ce dernier ne peut pas être choisi au hasard, mais vaut précisément : “alpha” = arctan(h/L). Nous comprenons donc qu’il faut orienter le cylindre noir (par exemple) d’un angle arctan(h/L). Enfin, nous procédons à la soustraction : Pavé rouge - Pavé gris, afin de ne se retrouver qu’avec le trapèze 3D décrivant le plan incliné.

Circuit électronique

Rappel du fonctionnement: Avec les pièces que l’on a construites, on veut faire arriver un signal sur un capteur, ce signal correspondant aux variations d’intensité lumineuse de la lumière produite par un laser. Ces variations d’intensité lumineuses sont directement liées à la vitesse de rotation de la roue, et donc au débit. Un débit grand produira plus de variations en moins de temps, un débit faible en produira moins. Si l’on décide d’un débit de référence connu, et qu’on mesure quelle est la vitesse de rotation de la roue qu’il engendre (et en faisant l’hypothèse que la variation du débit en fonction de la vitesse de rotation est linéaire) on pourra trouver n’importe quel débit en utilisant ce débit de référence et une vitesse de rotation mesurée avec notre instrument.

Sélection du capteur adapté: D’après ce que nous avons décrit précédemment, nous avons besoin d’un capteur très sensible aux variations d’intensités lumineuses. Après avoir fait quelque tests, nous avons décidé de choisir une photo-résistance (à la lumière ambiante la valeur de sa résistance vaut environ 30kohm, à la lumière artificielle elle vaut environ 20kohm, et quand on la cache de la lumière elle vaut près de 100kohm). Nous nous sommes rendus compte que notre montage, tenant compte de tous les supports, cachait assez bien la photo-résistance de la lumière ambiante, donc le mode “lampe” de notre pointeur laser suffirait pour produire des variations mesurables. Par ailleurs, on évite comme cela d’avoir à aligner parfaitement la photorésistance et le laser.

Circuit: L’arduino est capable de lire des tensions. Il nous faudrait donc alimenter notre photo-résistance en courant, puis lire la tensions à ses bornes: d’après la loi d’Ohm, la tension est proportionnelle à la valeur de la résistance (donc haute tension si obscurité → blocage de la lumière par la roue, tension faible si lumière → passage de la lumière par un trou de la roue). Cependant, on décide d’utiliser l’Arduino comme générateur aussi, et elle sert uniquement comme générateur de tension. Désormais, il ne nous suffit plus d’alimenter la photorésistance en tension puis juste lire la tension à ses bornes: on va toujours lire ce qu’est produit par l’Arduino et on ne va pas avoir de variation de tension. C’est pour cette raison que l’on fait appel à un montage pont diviseur de tension, avec une première résistance de valeur 10kohm (valeur standard, pas de choix particulier).

De toute façon, la tension lue par l’Arduino évolue de la même façon qu’avant en fonction des variations de résistances: elle va augmenter quand la résistance est forte, diminuer quand elle est faible.

Traitement du signal

Signal produit en sortie du montage: Notre but est de faire interpréter à notre programme que quand la photorésistance est éclairée, il doit mesurer un temps, et quand elle ne l’est pas, la mesure doit s’arrêter. Avec cela, on saura combien de temps dure le passage de la lumière dans un trou (temps court → rotation rapide, débit fort / temps long → rotation lente, débit faible). Le problème se pose alors de comment faire pour que l’Arduino interprète les notions “photorésistance éclairée” et “photorésistance non éclairée”. Notre première idée est d’utiliser un montage comparateur: on compare la valeur de la tension aux bornes de la photorésistance et une tension de référence créée avec un montage pont diviseur et des résistances connues grâce à un AOP. Cette tension de référence serait inférieure à la tension aux bornes de la photorésistance quand elle est éclairée, mais inférieure à la tension aux bornes de la photorésistance quand elle ne l’est pas. De cette façon, en sortie de l’AOP, on a un signal binaire au lieu d’une suite de valeurs continues: soit il y a de la tension, soit non. On peut alors utiliser une fonction sur Arduino qui déclenche un compteur de temps quand elle reçoit une tension, et qui l'arrête quand elle n’en reçoit plus. On voit bien maintenant que cette idée aurait marché, mais elle était loin d’être efficace. Toutefois, c’était la seule manière que l’on connaissait pour procéder: on s’était beaucoup formés en électronique au premier semestre, et beaucoup moins en numérique, et cela explique pourquoi on était plus à l’aise. Mais avec une introduction rapide au fonctionnement du codage en C, faite par notre enseignant, on a vu qu’on pouvait régler notre problème avec juste quelques lignes de codes, sans avoir à faire appel à un montage comparateur.

Code:
Initialisation et partie voidloop(): On décide premièrement de voir comment se fait la lecture des valeurs de la tension sur l’Arduino. On fera cela grâce à la fonction Serial.print(), qui nous sera très utile. On lit la tension aux bornes de la photorésistance et on voit que l’Arduino affiche 400 quand la photorésistance n’est pas éclairée, et 200 quand elle l’est. Il nous faut donc une tension de seuil d’environ 300. On fait le choix arbitraire de mesurer un temps quand la lumière passe à travers le trou (on aurait pu mesurer le temps d’obscurité, au lieu du temps d’éclairement). On fait cela grâce à la fonction millis(), qui donne le temps à la milliseconde près depuis que le programme a commencé à s’exécuter, en utilisant l’horloge de l’ordinateur. On va mesurer ce temps plusieurs fois, c’est-à-dire pour plusieurs trous. On définit alors une variable temps_20_trous qui sera la différence de temps entre la fin et le début d’une boucle, et cette boucle sera simplement un compteur de 20 trous, c'est-à-dire de 20 fois un passage de lumière.

Maintenant il nous faut relier ce temps_20_trous au débit correspondant. Pour cela, on fait l’hypothèse de proportionnalité, comme on l’a dit auparavant. On affiche plusieurs fois le temps_20_trous d’un débit connu, qu’on a créé avec une jarre disposant d’un robinet. Alors, on a un temps_20_trous_ref qui correspond à un debit_ref. Si ensuite on mesure un autre le temps_20_trous d’une autre écoulement, quel qu’il soit, avec une règle de 3 on pourra le relier à la valeur de son débit, et l’afficher.

Partie voidsetup(): Pour finir, il nous faut une façon de déclencher notre boucle: on veut commencer à la faire tourner qu’au moment qui nous intéresse. On décide qu’au début, quand on ne veut pas faire de mesure, la lumière n’est pas allumée: de cette façon, la tension est toujours supérieure à la tension de seuil, on reste dans la boucle du voidsetup() et on affiche “Pas de débit”. Quand on veut faire une mesure, on allume la lumière, mais on la positionne la roue de telle sorte que la lumière soit cachée: on ne sort toujours pas de la boucle, mais on est prêts. Quand on commence à verser de l’eau, la photorésistance reçoit une première fois une lumière intense, la tension passe en dessous de la tension de seuil et on sort de cette boucle, on reste désormais dans la boucle du voidloop() jusqu’à la fin, et on affiche un débit.

Groupe A3 : Vérification de la loi des gaz parfaits

Vérification de la loi des gaz parfaits

Membres du groupe

Étudiants en CMI Physique (groupe A3)

Introduction

Dans le cadre de l’UE FabLab (LU1SXPFL), nous devions réaliser un instrument de mesure. Nous nous sommes intéressés à la réalisation d’un outil permettant de vérifier la loi des gaz parfaits (PV = nRT), une relation bien connue depuis le lycée qu’on applique régulièrement sans vraiment se poser de questions. Nous devions donc trouver un moyen de vérifier la conservation du rapport existant entre la pression et la température ; nous nous sommes pour cela mis d’accord de concevoir une boîte adiabatique à volume constant et à quantité de matière supposée constante, comprenant un système de mesures et dont on peut chauffer l’intérieur dans le but de vérifier la relation.

Nous vous invitons à consulter ce journal de bord, mené au fur et à mesure de la réalisation de notre projet, détaillant la totalité de nos idées, manipulations, problèmes survenus, etc.

Élaboration du projet

Semaine du 24/01

Découverte de l'UE

Nous avons découvert cette nouvelle UE et avons commencé à réfléchir à des idées de projets à réaliser. Nous pensions au début à réaliser un outil mesurant la vitesse entre deux positions, puis un outil mesurant la vitesse grâce à un accéléromètre mais ces outils nous semblent finalement trop simples. Nous sommes encore hésitants mais nous avons un penchant pour la conception d'un altimètre, un instrument de mesure permettant de mesurer l'altitude ou la distance verticale entre un point et une surface de référence. Nous devons encore nous renseigner davantage sur le fonctionnement de cet outil de mesure.

Découverte des logiciels Inkscape et FreeCAD

Durant le week-end, nous avons commencé à prendre en main les logiciels Inkscape (pour le dessin vectoriel en 2D) et FreeCAD (pour les modélisations en 3D).

https://inkscape.org/

https://www.freecadweb.org/?lang=fr

Semaine du 31/01

Découverte des logiciels Inkscape et FreeCAD

Durant la séance, nous avons poursuivi notre découverte des deux logiciels. Nous avons commencé par réaliser une première forme en 3D dans FreeCAD. Nous avons dû réaliser un cube de 5 mm de côté, dont chacune des faces soit être percée par un trou de 1 mm de rayon. Nous avons eu un peu de mal au début à prendre le logiciel en main mais grâce à un tutoriel sur YouTube, nous y sommes finalement parvenus. Pour ce faire, nous avons commencé par créer une esquisse de taille 5 mm par 5 mm. Nous avons ensuite utilisé l'outil “Protusion” pour ajouter une dimension à notre esquisse et se retrouver avec un cube. Nous nous sommes ensuite ramenés par chacune des dimensions à un plan, dans lequel nous avons réalisé des cercles et nous avons finalement utilisé l'outil “Perçage” pour percer chacune des dimensions grâce aux formes de cercles établies plus tôt.

Dans un second temps, nous avons réalisé une forme en 2D sur le logiciel Inkscape. Nous avons dû réaliser un carré de 50 mm de côté, avec un cercle de 2 mm de rayon à chacun des quatre coins du carré. Chaque cercle doit se situer à 1 mm du bord du carré. Nous avons simplement tracé un carré de 50 mm de côté, grâce à l'outil “Créer des rectangles et des carrés”. Nous avons par la suite réalisé quatre cercles, grâce à l'outil “Créer des cercles”. Ensuite, en utilisant l'outil “Editer les noeuds et les poignées de contrôle d'un chemin”, nous avons pu sélectionner chaque rond avec la forme de carré et, en se rendant dans “Chemin” > “Division”, nous avons pu percer le carré avec les formes de cercles. Finalement, nous avons appliqué au tout un contour rouge de largeur 0,5 mm.

Nous avons par la suite, toujours durant la deuxième séance, continué à réfléchir en groupe sur notre projet. Nous voulions initialement rester sur notre idée d’altimètre mais après des recherches, on s’est vite rendu compte que la seule manière d’y parvenir était de récupérer la pression puis d’utiliser une relation liant pression et altitude. Nous avons essayé de trouver une manière de déterminer la pression en cherchant du côté de la relation des gaz parfaits. Mais nous avons été freinés par le volume et la quantité de matière qui étaient trop compliqués à exploiter pour en tirer une pression. Dans l’incapacité de créer par nous-même un capteur de pression, il est donc indispensable d’en utiliser un pré-fait ; ce qui rend la tâche bien trop simple pour notre projet. Nous devions donc changer d’idée. Lorsque nous étions encore axés sur l’altimètre, nous évoquions la relation des gaz parfaits

Une autre idée intéressante de projet serait donc un dispositif qui vérifie cette loi. On peut mesurer différents couples pression-température et voir si on retombe bien sur le volume molaire.

Découverte de la découpeuse laser et l'imprimante 3D

Vendredi après-midi, nous nous sommes rendus au FabLab pour imprimer/découper les visuels que nous avons réalisés mardi en cours. Grâce à l'aide d'un étudiant qui tenait le FabLab, nous avons pu découvrir en détail le fonctionnement de la découpeuse laser ainsi que de l'imprimante 3D.

Du côté de la découpeuse laser, nous avons tout d'abord appris à effectuer une impression depuis Inkscape grâce au logiciel dédié de la découpeuse laser. On a pu nous-même calibrer avec précision la tête de la découpeuse en hauteur mais aussi bien la positionner par rapport aux plaques de bois. On a vu comment manipuler la découpeuse avec précaution, surveiller le déroulement de la découpe, les manipulations à respecter…

Nous avons réalisé deux découpes de la même forme aux bonnes dimensions, telles qu'initialisées dans Inkscape. La première (que l'on peut voir sur la partie droite de l'image ci-contre) a été faite en découpant une plaque de contre plaqué de 3 mm d'épaisseur. Néanmoins, la plaque était initialement légèrement courbée ce qui a fait que les quatre trous aux extrémités du carré (découpés après la forme rectangulaire principale) ont mal été découpés et se sont retrouvés à moitié à l'extérieur de la forme, comme on peut le voir sur les photos. Nous avons donc retenté l'impression en découpant une seconde plaque (que l'on peut voir sur la partie gauche de l'image) de bois MDF de 5 mm d'épaisseur, complètement plate cette-fois. Le rendu est nettement meilleur.

Dans un second temps, nous nous sommes intéressés à l'impression 3D de notre cube. Nous avons commencé par exporter notre objet de FreeCAD dans l'extension “.stl”. Nous l'avons ensuite ouvert dans le logiciel ideaMaker (le logiciel relié à l'imprimante 3D) où nous aurions pu, si besoin, changer l'inclinaison et la taille de notre objet. Nous avons conservé les dimensions

initiales de 5 mm x 5 mm. Nous avons par la suite sélectionné les réglages d'impression, notamment le remplissage à l'intérieur de notre objet, la précision de l'impression, la présence ou non d'une base, etc., de nombreux paramètres qui influencent la durée d'impression. Finalement, nous avons exporté l'objet sur une clé USB que nous avons branchés sur l'une des imprimantes 3D du FabLab. Une fois celle-ci allumée et prête, nous avons démarré l'impression qui fut relativement rapide, ayant duré moins de 4 minutes. Nous nous sommes rendu compte durant l'impression que les dimensions imposées étaient vraiment petites. En effet, le rendu aurait sûrement été meilleur en choisissant des dimensions plus importantes. Quoi qu'il en soit, le rendu est tout de même très correct pour une telle taille d'impression ; les détails, notamment les trous à l'intérieur, restent très bons, comme on peut le voir sur les photos ci-contre.

Semaine du 07/02

Initiation à l'Arduino

Lors du cours du mardi 8 février, nous avons commencé à toucher aux Arduino. Nous avons découvert le kit contenant de nombreuses choses, notamment un Arduino Nano, de nombreux capteurs (tactile, à ultrasons, infrarouge, de luminosité, de température…), des modules d'affichage, des DEL, etc.

Dans un premier temps, après avoir branché l'Arduino en USB à l'ordinateur, nous avons réalisé un circuit relativement simple. Nous avons simplement relié la tension sortante de l'Arduino (de 5 V) à une ligne d'une plaque de prototypage et la terre à une autre ligne. Nous avons ensuite branché en série une DEL bleue avec une résistance de 330 Ω. Sans surprise, elle s'allume.

Dans un second temps, nous avons un peu enrichi notre circuit. Nous avons ajouté une seconde DEL (une DEL de couleur rouge) et nous souhaitons faire clignoter les deux DEL en utilisant l'Arduino. Pour ce faire, nous avons d'abord téléchargé le logiciel Arduino IDE

 Nous nous sommes ensuite mis à la recherche d'un code permettant de réaliser le clignotement des DEL. Nous en avons rapidement trouvé un qui correspondait parfaitement à nos attentes (voir la source). Nous l'avons donc copié dans le logiciel de l'Arduino et avons modifié le circuit en conséquence. Nous avons placé la terre sur l'entrée “GND” de l'Arduino et la tension positive sur “2”. Nous obtenons finalement le résultat souhaité ; les deux LED clignotent correctement (allumées pendant 0,5 seconde et éteintes pendant 0,5 seconde) à l'infini.

https://www.arduino.cc/en/software

Ensuite, nous voulions tester un autre système. Nous voulions essayer l'afficheur de chiffre, à 1 caractère. Nous avons de nouveau procédé à quelques recherches sur internet jusqu'à trouver une page expliquant comment l'utiliser (voir la source). Néanmoins, après de nombreuses tentatives, cela n'a pas fonctionné. Nous avons donc poursuivi nos recherches jusqu'à tomber sur une page du site officiel d'Arduino qui présentait un code et son montage électrique (voir la source). Nous avons donc utilisé le code fourni et branché tous les câbles. L'une des terminaisons de l'afficheur est branchée à la terre, tandis que presque toutes les autres terminaisons sont reliées à l'Arduino (voir la photo ci-contre). Cette fois-ci, après plusieurs essais en raison d'un problème dans le code d'abord, et de branchement ensuite, tout a bien fonctionné et nous avons pu voir sur l'afficheur une suite de chiffres défiler (de 0 à 9).

Finalement, durant la dernière demi-heure du cours, nous avons tenté de nous pencher sur le capteur de température. Nous voulions essayer de récupérer une valeur de température pour l'afficher sur notre afficheur (du moins afficher le dernier chiffre de cette valeur par exemple). Néanmoins, malgré une page internet assez précise (voir la source), nous ne sommes pas parvenus à le faire fonctionner. Nous aurions éventuellement pu se documenter davantage pour régler le problème si nous n’avions pas été limités par le temps.

Semaine du 14/02

Réflexion sur notre projet

Au cours de cette quatrième séance, nous nous sommes pleinement consacrés à la réflexion concernant notre projet. Après quelques instants de réflexion, nous avons finalement validé notre idée de projet : celle de réaliser un outil permettant, grâce à des mesures, de vérifier la relation des gaz parfaits. Celle-ci se présenterait de la manière suivante : nous aimerions concevoir une boîte adiabatique, isolée thermiquement donc, contenant un système de mesures de températures et de pressions. La boîte, à volume constant et supposée complétement isolée de l’environnement extérieur, aurait donc un volume et une quantité de matière constante. Ajouté à la constante des gaz parfaits, il nous suffira juste de recueillir différents couples volume-pression, de déduire pour chacun d’entre eux le volume molaire et de finalement comparer ces derniers (devant théoriquement être égaux).

 Pour pouvoir aisément obtenir différents couples volume-pression, il nous paraît envisageable de mettre en place, à l’intérieur de la boîte, un système chauffant permettant de faire varier la température (et donc la pression) dans l’environnement d’étude (l’intérieur de la boîte). Pour ce faire, nous avons étudié différents systèmes, à savoir l’effet Peltier (que nous avons vite éliminé car il produit certes de la chaleur mais également du froid), l’ajout de grosses résistances et enfin l’utilisation de fil de cuivre. Pour des raisons pratiques, nous avons sélectionné l’option du fil de cuivre ; facilement enroulable (donc permettant un gain de place) et allongeable (pour facilement augmenter la valeur de la résistance, donc l’effet Joule).

Nous voulions avoir une idée numérique de la variation de température générée grâce à l’utilisation de telle ou telle intensité/tension mais nous avons vite été freinés par la difficulté des calculs, bien trop complexes et prenant en compte trop de facteurs. Après discussion avec notre professeur, nous avons finalement pris l’initiative de se charger expérimentalement (lors de la mise en place du projet) du choix de la longueur de fil nécessaire ainsi que du courant et de la tension, avec un courant qui sera bien sûr variable de sorte à obtenir une température plus ou moins élevée. Ainsi, nous ne définirons pas une température à atteindre mais nous atteindrons une température « aléatoire » que nous mesurerons par la suite.

En parallèle du système chauffant (sûrement alimenté par un générateur extérieur sur secteur), nous mettrons en place un circuit composé d’un Arduino Uno (si possible alimenté par une batterie), de capteurs de pression et de température, et d’un écran affichant la pression, la température et le volume molaire (si possible visible de l’extérieur de la boîte).

Nous avons ensuite commencé à réfléchir au matériau principal qui composera notre boîte, un matériau devant être un bon isolant thermique. Nous avons pensé au bois qui isole assez bien, est léger, peu coûteux et même plutôt esthétique. Nous ne nous sommes cependant pas attardés plus que ça sur la boîte en elle-même (pour le moment) pour une raison assez simple. Nous évoquions précédemment le gain de place – la boîte devra être la plus petite possible afin que l’intérieur soit le plus simple possible à chauffer –, donc nous devrons optimiser un maximum sa taille. Cependant, ne connaissant pas encore exactement le remplissage interne du système, il nous est impossible pour le moment d’estimer la taille de la boîte. 

Réalisation du projet : capteur de température

Ayant bien avancé sur le principe de notre projet, nous voulions commencer la réalisation. Nous avons premièrement souhaité reprendre notre expérience non aboutie de la semaine dernière, à savoir la mesure de la température. Nous avons néanmoins grandement réduit le circuit en supprimant complètement, pour le moment, l’écran d’affichage. Nous avions donc seulement le capteur de température relié à l’Arduino (via une plaque de prototypage), avec la valeur de la température devant s’afficher dans le moniteur du logiciel Arduino IDE. Nous avons commencé avec un premier montage trouvé sur le site officiel d'Arduino (voir la source) présentant le fonctionnement pour un thermomètre de type DS18B20, que nous possédons au FabLab. Néanmoins, après le montage réalisé (nous n’avons malheureusement pas pensé à prendre une photo de ce montage) et le code téléchargé, nous avons rencontré une erreur systématique : la température affichée était tout le temps de -127 degrés Celsius. Cette valeur ne bougeait jamais, même quand on débranchait tous les fils, et inutile de préciser pourquoi celle-ci est absurde. D’après les commentaires sous le projet, pour ce problème précis (visiblement fréquemment rencontré), il était conseillé d’essayer un autre montage présenté sur un autre site (voir la source). Il s’agissait d’un montage assez similaire (si ce n’est identique même) que nous avons réalisé mais ne réglant pas le problème…

Grâce à l’initiative de notre professeur, nous décidons ensuite de changer le thermomètre par un autre présent au FabLab, de référence LM35. Nous partons à la recherche d’un autre montage (voir la source) qui sera cette fois-ci davantage concluant. Il s’agit du circuit ci-contre. Non seulement ce circuit est bien plus simple que le premier (moins de fils et pas de résistance), mais celui-ci nous affiche (grâce au code fourni) une valeur variable (pas comme la constante que nous avions précédemment) et plausible (22 et quelques degrés Celsius, soit une température ambiante d’une pièce). Seul bémol : lorsque nous recouvrons le capteur avec un doigt (pour augmenter sa température), nous montons presque instantanément à 100 et quelques degrés. Après lecture rapide du code, nous supposons que le problème doit provenir de la ligne 12 ; il y a une sorte d’initialisation d’une variable, nommée « mv », servant probablement de calibration du capteur. Ces valeurs sont certainement fausses.

Malheureusement, la séance touche à sa fin et nous n’aurons pas le temps d’approfondir ce sujet aujourd’hui, bien que nous nous y consacrerons la prochaine fois.

Semaine du 21/02

Réalisation du projet : capteur de température

Nous revoilà le mardi 22 février pour la suite de la réalisation de notre projet. Nous avons dans un premier temps repris là où nous nous étions arrêtés la dernière fois. Pour rappel, nous tentions de réaliser une mesure de la température grâce au capteur LM35, présent au FabLab. Néanmoins, si la valeur affichée en sortie (dans la console du logiciel) était plausible, lorsque nous recouvrions le capteur avec un doigt (pour augmenter sa température), nous montions presque instantanément à 100 et quelques degrés. Nous pensions que le problème provenait d’un souci de calibrage du capteur dans le code utilisé. Nous étions donc partis aujourd’hui dans l’optique de régler ce problème mais en rebranchant le tout et en exécutant le programme, tout fonctionnait cette fois-ci très bien. La température affichée était initialement de 21 et quelques degrés puis en couvrant le capteur avec un doigt, nous sommes montés jusqu’à environ 30 degrés en un peu moins d’une minute. En retirant le doigt, la température redescendait progressivement à 21 degrés. Tout paraît donc parfaitement cohérent. On en déduit donc que le problème de la dernière fois ne provenait pas d’une erreur de code mais plutôt d’un capteur probablement défectueux.

Réalisation du projet : afficheur LCD

Maintenant qu’on a une valeur de température correcte, nous souhaitons l’afficher. Et pour ça, quoi de mieux qu’utiliser un afficheur LCD. Nous partons donc à la recherche d’un code et d’un montage utilisable. Nous avons pas mal de mal à trouver une solution qui fonctionne (trois montages différents réalisés mais aucun de marche). Nous trouvons finalement une vidéo décrivant assez bien le procédé (voir la source). Après avoir réalisé le montage décrit (en parallèle de notre montage réalisé plus tôt pour mesurer la température), nous arrivons bien à faire fonctionner l’afficheur.

Nous souhaitons à présent afficher sur l’afficheur LCD notre température mesurée plus tôt. Nous réalisons quelques modifications dans le code et nous pouvons facilement arriver au résultat attendu. On peut voir que cela fonctionne parfaitement. L’afficheur LCD se met à jour en permanence.

Réalisation du projet : capteur de pression

Une autre fonctionnalité à implémenter impérativement dans notre système est un capteur de pression (essentiel pour la vérification de la loi des gaz parfaits). Nous parvenons à nous procurer un capteur de pression barométrique, de référence BMP180 GY-68. Nous réalisons le montage proposé sur un site (voir la source) et nous y récupérons le code. Néanmoins, nous rencontrons un problème avec celui-ci. Il semble avoir besoin de l’altitude et de la température pour déterminer la pression… Nous n’aurons malheureusement pas le temps d’approfondir le sujet. Nous reprendrons ça lors des prochaines séances.

Semaine du 07/03

Réalisation du projet : capteur de température

De retour après deux semaines pour la suite de la réalisation du projet. Nous avons tout d’abord souhaité refaire fonctionner notre montage de la dernière fois. Néanmoins, suite à un problème surprenant survenu, nous n’avons pas réussi à retrouver notre température réelle obtenue auparavant. Nous avons donc passé près de deux heures à tenter de retrouver une mesure de températures fonctionnelle, en essayant un capteur de température LM35 ainsi qu’un TMP37. En suivant différents montages, différents codes et différentes calibrations (voir montage 1, montage 2, montage 3 et montage 4). Dans tous les cas, nous avons systématiquement une température trop importante (de 36/37 degrés en moyenne) qui monte à des valeurs incohérentes (50/70/100 degrés Celsius) en un rien de temps, en touchant à peine le capteur avec un doigt.

Nous ignorons la provenance de ce problème mais nous comptons l’analyser plus en détail au cours de la prochaine séance, lorsque nous aurons accès à un thermomètre dans la salle afin de connaître la vraie valeur de la température et de pouvoir faire une calibration correcte du capteur de température. Nous reprendrons aussi à ce moment-là la réalisation du capteur de pression.

Réalisation du projet : réalisation du système chauffant

Nous avons en parallèle commencé à nous charger de l’élaboration du système permettant le chauffage de notre boîte. Pour ce faire, nous utiliserons une bobine de cuivre dans laquelle nous ferons passer un courant, suffisant important pour la faire chauffer. Nous avons choisi un fil de cuivre plutôt épais et avons coupé une longueur d’un mètre.

Nous avons d'ores et déjà testé le principe avec deux sources de courant différentes : la première, délivrant maximum 1 A, mais qui ne chauffait presque pas la bobine ; la deuxième, délivrant un courant de maximum 20 A, chauffant cette fois-ci assez bien (et rapidement) notre fil de cuivre. C’est donc le deuxième générateur qu’on retiendra pour la suite.

Ainsi, nous avons fait chauffer un fil simple, dont nous n'avions pas changé la forme. Pour ce faire, nous avons connecté le fil de cuivre à un générateur de courant délivrant un courant maximal de 20 A, ce qui est très élevé. Nous avons augmenté le courant progressivement lors de nos tests et sommes très rarement arrivés au niveau de ce courant limite car ce n'était pas souvent nécessaire et un courant très élevé est dangereux. Ce premier test n'était donc pas concluant car le fil ne chauffait rien du fait qu'il était droit et ne chauffait pas du tout les alentours.

Nous réaliserons dans les prochaines semaines d’autres expériences afin de concevoir une bobine chauffant suffisamment l’intérieur de la boîte.

Réalisation du projet : réalisation de la boîte contenant notre dispositif

Nous avons finalement un peu discuté de l’élaboration de notre boîte qui accueillera notre dispositif. Conformément à ce que nous pensions il y a quelques semaines, cette boîte (devant être adiabatique, donc isolée thermiquement) sera probablement réalisée en bois. Elle devra comporter l’Arduino, la carte de prototypage ainsi que tous les composants électroniques nécessaires, et la bobine de cuivre. Un afficheur LCD sera visible depuis l’extérieur de la boîte. En termes de dimensions, nous partirons donc sur 20 cm de longueur (afin de pouvoir correctement faire entrer la carte de prototypage), 15 cm de profondeur et la hauteur reste encore à définir, bien que celle-ci ne doive pas être trop grande (plus la boîte est grande et plus elle sera compliquée à chauffer). Les planches de bois formant la boîte devraient être de 1 cm d’épaisseur environ, afin que la boîte soit solide et la plus adiabatique possible.

Semaine du 14/03

Réalisation du projet : capteur de température

De retour au problème qui nous occupait lors de la dernière séance : le capteur de température. Pour rappel, notre température mesurée ne faisait que bouger et était bien trop importante, malgré l’essai de plusieurs montages et de plusieurs capteurs de température. Nous sommes donc retournés à un circuit basique avec juste le capteur de température (un classique LM35) et l’Arduino, avec un autre Arduino Uno. Et là, tout fonctionnait parfaitement ! On déplace alors l’écran LCD et pareil, ça marche. Le problème est enfin réglé ; il s’agissait bêtement d’un problème du côté de l’Arduino…

Réalisation du projet : capteur de pression

Cela étant fait, nous nous attaquons à l’installation du capteur de pression. Comme la dernière fois que nous avons tenté d’obtenir la pression, nous nous procurons un capteur de pression barométrique de référence BMP180 GY-68. Nous réalisons un montage proposé sur un site trouvé (voir la source) et nous y récupérons le code. Néanmoins, nous rencontrons un problème avec celui-ci. Pour une raison que nous ignorons, nous n’arrivons pas à faire la relation entre l’Arduino et le capteur. Nous avons tenté de nombreuses choses mais cela ne marche toujours pas. Nous avons même fait appel à plusieurs professeurs mais rien… Nous retenterons la prochaine fois avec un autre capteur d’une autre référence, commandé entre temps.

Réalisation du projet : réalisation du système chauffant

Nous avons réitéré l’expérience de la dernière fois et en avons cette fois en plus conclu que le fait d’enrouler le fil de cuivre (plutôt que de le laisser en ligne droite) permettait la production et le dégagement de davantage de chaleur. Cependant, le fil étant beaucoup trop petit pour chauffer suffisamment ses alentours, cela ne fonctionne pas correctement pour notre boîte. Nous devrons donc utiliser une bobine plus longue.

Réalisation du projet : réalisation de la boîte contenant notre dispositif

Nous avons finalement pris un peu de temps pour avancer sur l’élaboration de notre boîte. Suite aux conseils d’un professeur chargé de la découpe laser, nous avons renoncé au bois comme matériau constituant notre boîte, en faveur de plexiglas (plus adiabatique semblerait-il). Nous réaliserons ainsi une boîte de 21 (20 + 1) cm de long, 16 (15 + 1) cm de profondeur et 11 (10 + 1) cm de hauteur, en prenant pour chaque dimension 1 cm de marge pour l’assemblage. Nous réaliserons la découpe à la découpeuse laser et nous en profiterons pour faire certaines découpes précises dans les parois, pour laisser passer certaines connectiques (le port USB de l’Arduino, les connexions pour les câbles alimentant la bobine) et l’écran LED de l’Arduino (affichant les informations de température et de pression).

Nous nous sommes rendus au FabLab en dehors des cours pour poursuivre l’élaboration de notre dispositif.

Réalisation du projet : capteur de pression

Nous avons repris le montage de la dernière fois en changeant simplement le capteur de pression. Nous avons essayé avec un autre capteur BMP180 à 4 terminaisons, contrairement à l’autre qui en avait 5. Et cette fois-ci, cela fonctionne parfaitement !

Nous avons donc intégré le code dédié au capteur de pression, à notre code initial contenant le reste. Cependant, le capteur de pression comprend également un capteur de température. Nous avons donc deux valeurs de température différentes. Après quelques tests, les deux capteurs de température renvoient des valeurs de températures assez similaires. On décide donc de garder ces deux valeurs et de pendre leur moyenne pour plus de fiabilité.

Réalisation du projet : réalisation de la boîte contenant notre dispositif

Nous nous sommes également renseignés plus précisément sur les matériaux à disposition pour la boîte. Nous avons trouvé des planches de plexiglas qui pourront sûrement satisfaire nos besoins. Elles font 60 cm de long, 30 cm de large et 0,5 cm d’épaisseur. Nous réaliserons donc les fichiers pour la prochaine séance afin de pouvoir débuter la découpe des parois de la boîte.

Semaine du 21/03

Réalisation du projet : réalisation de la boîte contenant notre dispositif

Durant cette avant-dernière séance, nous nous sommes uniquement occupés de la réalisation de la boîte. Après avoir fignolé nos visuels pour la découpeuse laser, nous avons débuté la découpe. Nous avons au début rencontré un problème : la découpeuse laser ne reconnaissait pas le rouge de la découpe, ce qui avait pour conséquence de ne rien faire du tout sur la plaque. Après avoir épaissi davantage les contours, nous sommes enfin passés à la vraie impression. Nous avons jusqu’ici conçu la base (A) qui correspond à la face inférieure de la boîte, la face avant (C), la face arrière (B) et les faces latérales (D). Nous nous occuperons la prochaine fois de concevoir la face supérieure de la boîte et nous imprimerons la face avant (C) car nous avons mal placé les deux embouts de l’Arduino, conformément à la paroi de droite.

Nous nous sommes rendus au FabLab en dehors des cours pour poursuivre l’élaboration de notre boîte.

Réalisation du projet : réalisation de la boîte contenant notre dispositif

Nous nous sommes occupés de découper les quelques parois que nous devions encore réaliser. Nous pourrons donc enfin nous attaquer dès la prochaine séance à l’assemblage de la boîte.

Semaine du 28/03

Nous nous retrouvons pour notre dernière vraie séance de FabLab avant les soutenances orales. Cette séance est donc plus que cruciale car nous prévoyons d’intégralement finir notre boîte ce jour (boîte + système électronique).

Réalisation du projet : réalisation de la boîte contenant notre dispositif

Nous commençons sans plus tarder à s’intéresser à l’assemblage de la boîte. Nous installons tout d’abord l’écran sur la paroi ; il rentre parfaitement grâce aux trous réalisés à l’aide de la découpeuse laser. Il est fixé à l’aide de vis et d’écrous.

N’ayant pas eu le temps de réaliser des encoches sur les plaques (afin de faciliter leur emboîtement), nous cherchons ensuite à coller nos plaques entre elles. Après le conseil de trois professeurs, nous suivons l’un d’entre eux qui a la grande gentillesse de nous emmener dans une salle afin de s’occuper du collage de nos plaques. L’opération est réalisée grâce à une colle polymérisable transparente adaptée au collage de plaques de PMMA (la matière de nos plaques, couramment appelée plexiglas). Cette colle est cependant assez toxique et dangereuse, elle nécessite d’être manipulée avec protections en utilisant des gants et dans une salle spéciale équipée d’une hotte et de systèmes d’aération poussés.

Réalisation du projet : exploitation des valeurs trouvées

En parallèle de l’assemblage de la boîte, nous travaillons sur l’exploitation des grandeurs mesurées grâce au dispositif (la pression et la température) afin de montrer le fonctionnement de la relation des gaz parfaits. Après plusieurs idées et différentes discussions avec notre professeur, nous arrivons à l’idée suivante. Nous mesurons la pression et la température, donc nous disposons de ces deux valeurs. Nous pouvons dans un premier temps utiliser la pression mesurée et s’en servir pour obtenir par le calcul la valeur de la température, grâce à la relation T,calculée = (P,réelle * V) / (n * R), avec P la pression mesurée, V le volume de la boîte, n la quantité de matière et R la constante universelle des gaz parfaits.

Pour l’application numérique, nous utilisons la pression mesurée par le capteur (variant donc en fonction de la température), le volume étant constant (estimé à L*l*h, soit 18,9 cm * 14,8 cm * 9,1 cm, soit V = 0,0025 m3) et la constante universelle des gaz parfaits (approximée à R = 8,314 J/(MK)). En ce qui concerne la quantité de matière, nous n’avons d’autres choix que de réaliser un calibrage à un instant initial, à température et pression ambiante ; il serait en effet trop compliqué de trouver cette valeur différemment. Nous sommes donc contraints d’utiliser initialement la relation des gaz parfaits pour notre dispositif. Nous calculons cette valeur grâce à l’équation n = (P,init * V) / (R * T,init), avec par exemple P,init = 1005 hPa = 100500 Pa et T,init = 24 °C = 297,15 K. On obtient dans ce cas n = 0,1 mol.

Nous pouvons ensuite comparer la valeur de température déterminée analytiquement avec celle mesurée en faisant la moye

nne des valeurs renvoyées par les deux capteurs de température (le LM35 et le capteur de pression BMP180 mesurant aussi la température). Pour ce faire, nous pouvons voir si la valeur mesurée T,réelle (la vrai valeur de température mesurée) est comprise dans l’intervalle [T,calculée – δT,calculée ; T,calculée + δT,calculée] avec T,calculée la valeur de température calculée grâce à la méthode décrite plus tôt et δT,calculée l’incertitude absolue de la valeur de température calculée.

Concernant les incertitudes, relevons les différentes incertitudes possibles à prendre en compte lors de notre calcul de la température (et donc de la quantité de matière) :

• Pression : le capteur BMP180 est précis à 3 Pa près (d’après la fiche technique du constructeur), donc δP,réelle = 3 Pa.
• Température mesurée : les capteurs LM35 et BMP180 sont précis à 0,5 °C (ou K) près (d’après les fiches techniques des constructeurs), donc δT,réelle = 0,5 K.
• Volume : tout d’abord, nous avons mesuré les dimensions internes de notre boîte en utilisant une règle classique graduée en mm, ce qui produit des incertitudes de ± 0,5 mm sur chacune des dimensions, soit une incertitude du volume total de ± 10E–10 m3, ce qui est très petit à côté du volume (de 0,0025 m3). Cependant, il s’agit là du volume total de l’intérieur de la boîte. À cela, il faudrait théoriquement soustraire le volume d’espace occupé (par l’Arduino, la carte de prototypage, les différents câbles…). Cela est cependant bien trop compliqué à estimer. On peut calculer le volume de la carte de prototypage ainsi que de l’Arduino, on trouve en tout un volume de 0,0001 m3, très négligeable face au volume total (sans même parler du volume des câbles…). On ne prendra ainsi pas en compte les incertitudes pour les mesures de volume.
• Constante universelle des gaz parfaits : cela est une valeur approximée mais toujours utilisée (à notre niveau) à ce niveau de précision. Nous ne prendrons donc pas en compte les approximations/incertitudes pour cette grandeur.
• Quantité de matière (calcul de l’incertitude à partir des autres grandeurs) :
  δn+ = ( (P,init + δP,réelle) * V ) / ( R * (T,init - δT,réelle) )
  δn- = ( (P,init - δP,réelle) * V ) / ( R * (T,init + δT,réelle) )
  δn = (δn+ – δn-) / 2 = 0,0002 mol
• Température calculée (calcul de l’incertitude à partir des autres grandeurs) :
  δT,calculée = (δT,calculée+ – δT,calculée-) / 2
  ⇒ δT,calculée = ( ( ( (P,réelle + δP,réelle) * V ) / ( R * (n - δn) ) ) – ( ( ( (P,réelle - δP,réelle) * V ) / ( R * (n + δn) ) ) / 2
  L’incertitude de la température dépendant de la valeur de pression (P,réelle), il est impossible de calculer cette valeur en amont ; c’est donc l’Arduino qui calcule en temps réel l’incertitude associée à la température calculée pour chaque valeur de pression mesurée.

• Qualitativement, nous pouvons également prendre en compte le fait que la boîte réalisée n’est pas forcément complètement adiabatique et qu’il y a donc des pertes de chaleur ; la boîte n’est donc pas un environnement 100% clos.

Pour revenir à l’exploitation des grandeurs mesurées, nous réalisons donc un code vérifiant si la valeur mesurée T,réelle est bien comprise dans l’intervalle [T,calculée – δT,calculée ; T,calculée + δT,calculée]. Si tel est le cas, l’écran du dispositif affiche « PV=nRT », sous-entendu que la relation est vérifiée. Sinon, l’écran affiche « PV≠nRT » si la relation n’est pas vérifiée.

Réalisation du projet : réalisation du système chauffant

Il y a quelques semaines, nous étions arrivés à un système chauffant plutôt fonctionnel qui chauffait un minimum. Néanmoins, le fil étant beaucoup trop petit pour chauffer efficacement ses alentours. Nous avons ainsi confectionné aujourd’hui une bobine trois fois plus longue. Celle-ci chauffait ainsi bien mieux.

Réalisation du projet : réalisation de la boîte contenant notre dispositif

Après presque deux heures d’attente, nous récupérons enfin notre boîte terminée avec toutes les parois collées entre elles. Nous installons donc le système à l’intérieur en plaçant correctement l’Arduino à l’emplacement prévu, ainsi que la carte de prototypage. Nous relions ensuite tous les câbles à l’écran et nous rendons l’intérieur de la boîte un peu plus propre en faisant un peu de « Cable Management ». Nous nous apercevons d’un problème avec le capteur de pression BMP180 (et oui encore…), rapidement résolu en remplaçant le BMP180 à 4 terminaisons par un BMP180 à 5 terminaisons (on se rappelle pourtant que celui-ci ne fonctionnait pas il y a quelques semaines mais bref, estimons-nous heureux que ça marche…).

Nous n’aurons cependant malheureusement pas le temps aujourd’hui de tester le dispositif en conditions. Nous retournerons au FabLab avant la séance prochaine afin de finir complètement la boîte (qui est déjà très aboutie actuellement il faut le dire) et effectuer des tests de température.

Semaine du 04/04

Nous voici lors de la dernière semaine de notre projet. Nous nous rendons au FabLab lundi 4 avril durant l’après-midi afin de finaliser certains points.

Réalisation du projet : réalisation du système chauffant

Lors de la dernière séance de FabLab, nous n’avions pas eu le temps de réaliser des tests de température. Nous commençons donc par cela. Nous reprenons notre boîte de la dernière fois et tentons des tests. Néanmoins, nous nous apercevons que la température à l’intérieur de la bobine ne varie pas du tout. En effet, la bobine actuelle qu’on pensait assez efficace ne chauffait en fait pas suffisamment ; il nous faut donc réfléchir à une nouvelle bobine de cuivre.

Nous avons ainsi utilisé une bobine cinq fois plus longue. Celle-ci chauffait beaucoup et nous a permis d'effectuer nos tests finaux nécessaires à la réalisation de notre instrument sans aucun problème (on détaillera cela par la suite).

Une fois que nous avions la bonne bobine, nous avons soudé le montage décrit précédemment avec un fer à souder présent au FabLab. Nous avons utilisé une pointe de fer qui était chauffée à environ 400°C ainsi que de l'étain ; nous avons utilisé le plus petit diamètre d’étain disponible car celui-ci était amplement suffisant pour notre utilisation.

La soudure consiste à faire fondre l'étain, lequel se mettra sur la pointe de fer qui est en contact avec le fil que l'on veut souder. Ensuite, une fois l'étain posé sur chaque extrémité que l'on veut souder, on répète la même opération mais en faisant fondre l'étain posé sur les extrémités à souder. Cela permet de « coupler » celles-ci, ce qui accomplit la soudure.

Il est important de noter que nous avons pris connaissance des règles d'utilisation du matériel. Les soudures ont été faites de manière sécurisée et nous nettoyions régulièrement la pointe de fer en la frottant contre les « éponges » en laiton prévues à cet effet. De plus, nous avons couvert chaque point de soudure par une gaine en caoutchouc afin d'éviter les dangers liés au courant.

Nous avons d’ailleurs réalisé les soudures directement dans la boîte, à l’aide de deux petits trous percés à cet effet, comme vous pouvez le constater sur les photos ci-dessous.

Le système chauffant de la boîte étant à présent terminé, nous pouvons effectuer des tests de fonctionnement.

Conclusion

Application

Il est désormais temps de passer à l’application de notre dispositif pour tenter de vérifier la relation des gaz parfaits. Tout d’abord, on place la bobine correctement dans la boîte et on se relie au générateur de courant, ainsi qu’à un ordinateur faisant tourner le logiciel Arduino. Voici un aperçu du « Setup ».

On réalise donc la situation suivante : on fait chauffer l’intérieur de notre boîte (grâce à la bobine de cuivre alimentée par un courant de presque 20 A) et on mesure périodiquement la pression et la température. On effectue également le calcul de la température ce qui nous permet de comparer la température mesurée avec la température calculée. On reporte toutes les mesures dans un tableau, disponible ci-dessous.

Exploitation

On remarque qu’en l’espace d’une trentaine de minutes, la température à l’intérieur augmente de 28 K. Après avoir atteint les 322 K (environ 50 °C), la température n’évolue plus. Celle-ci stagne à cette valeur, comme si on avait atteint les capacités thermiques de notre bobine. Quoi qu’il en soit, une différence de 28 K est amplement suffisante pour notre expérience.

Vous pouvez néanmoins le voir dans le tableau ci-dessus : la pression mesurée n’évolue pas du tout. Elle reste constante à 1013 hPa (la pression dans la salle à ce moment-là, qui s’avère être exactement égale à la pression atmosphérique). Cela influe donc directement sur la valeur de la température calculée, constante également. Ce qui a pour effet que la différence entre la température calculée et la température mesurée (initialement très faible, à seulement 0,3 K) croît de plus en plus. Cela se voit également sur les deux graphiques suivants, respectivement la température et la pression mesurées en fonction du temps, et les températures mesurée et calculée en fonction du temps.

Interprétation

Ainsi, d’après les résultats obtenus, la loi des gaz parfaits n’est pas vérifiée. Le problème provient certainement de notre boîte qui échange de la matière avec l’extérieur. Ainsi, la boîte n’est pas correctement isolée et donc la pression dans la boîte vaut la pression ambiante de la pièce. Nous avons tenté à la dernière minute d’utiliser un pistolet à colle afin de combler le plus de trous possible mais nous n’y sommes malheureusement pas parvenus.

Conclusion sur le projet

Après réflexion, si nous n’avions pas manqué de temps, nous aurions pu travailler davantage sur la boîte afin de l’isoler complètement de l’extérieur. Nous aurions également pu penser à d’autres matériaux pour la boîte, comme le polystyrène par exemple, un très bon isolant.

Malgré ces problèmes rencontrés, nous sommes parvenus à réaliser un système de mesures assez intéressant à l’aide de capteurs et d’un Arduino. Nous avons également réussi à faire gagner à l’intérieur de notre boîte pratiquement 30 degrés, ce qui n’est pas négligeable du tout. Et finalement, nous avions une méthode d’exploitation des résultats assez bonne ainsi qu’un code associé adapté pour (si nous n’avions pas rencontré les problèmes de pression) déterminer la différence entre la température mesurée et calculée, et surtout leurs incertitudes associées afin de vérifier l’appartenance de la température mesurée à l’ensemble comprenant l’écart type de la température calculée. Le projet n’est donc pas complètement raté, loin de là !

Ce projet fut, sans conteste, très intéressant. Il nous a permis de bouleverser nos habitudes en mobilisant nos connaissances ainsi que nos capacités de recherche et de réflexion, d’une manière bien différente de ce dont on a l’habitude en L1. Nous avons pu découvrir énormément de choses : de l’impression 3D à la découpe laser, en passant par les Arduino, la programmation en C et l’algorithmique, l’utilisation concrète de l’électronique pour résoudre de vraies problématiques, le travail d’équipe sur plusieurs semaines pour mener à bien un projet scientifique ou bien même la sensation de travailler durement pour ne pas forcément aboutir à un résultat concret ou fonctionnel.

Code pour Arduino

Code du 04/04 :

// Initialisation pour capteur BMP180 :

#include <Wire.h>
#include <SFE_BMP180.h>

SFE_BMP180 bmp180;

// Initialisation pour capteur LM35 :

  int val;
  int tempPin = 1;

// Initialisation pour afficheur LED :

  #include <LiquidCrystal.h>  
  LiquidCrystal lcd(12,11,5,4,3,2);

void setup()
{
  lcd.begin(16,2); // utilisation d'un écran 16 colonnes et 2 lignes
  Serial.begin(9600);
  bool success = bmp180.begin();

  if (success) { // vérification sur le capteur BMP180 est bien connecté
    Serial.println("Initialisation réussie !");
  }else{
    Serial.println("Erreur : veuillez vérifier les branchements.");
  }
}

void loop()
{
  // Configuration du capteur BMP180
  
  char status;
  double T, P;
  bool success = false;

  status = bmp180.startTemperature();

  if (status != 0) {
    delay(1000);
    status = bmp180.getTemperature(T);

    if (status != 0) {
      status = bmp180.startPressure(3);

      if (status != 0) {
        delay(status);
        status = bmp180.getPressure(P, T);
      }
    }
  }
  
  val = analogRead(tempPin); // Lecture des données du capteur LM35
  float mv = (val/1024.0)*5000;

  // Température du capteur LM35
  float temperature_celcius_1 = mv/10;
  float temperature_kelvin_1 = temperature_celcius_1+273.15; 

  // Température/pression du capteur BMP180
  float temperature_celcius_2 = T;
  float temperature_kelvin_2 = temperature_celcius_2+273.15; 
  float pression = P*100;

  // Moyenne entre la température du capteur LM35 et du capteur BMP180
  float moyenne_temperature = (temperature_kelvin_2+temperature_kelvin_2)/2;

  // Valeur du volume (consulter le Wiki pour plus d'informations)
  float volume = 0.0025;

  // Valeur de la constante universelle des gaz parfaits
  float constante = 8.314;
  
  // Initialisation 
  float temperature_init = 294;
  float pression_init = 101400;
  float quantite_matiere = (pression_init*volume)/(constante*temperature_init);
  float incertitude_quantite_matiere = ((((pression_init+3)*volume)/(constante*(temperature_init-0,5)))-(((pression_init-3)*volume)/(constante*(temperature_init+0,5))))/2;

  // Calcul de la température
  float calcul = (pression*volume)/(constante*quantite_matiere);

  // Calcul de l'incertitude de la température calculée
  float incertitude = ((((pression+3)*volume)/(constante*(quantite_matiere-incertitude_quantite_matiere)))-(((pression-3)*volume)/(constante*(quantite_matiere+incertitude_quantite_matiere))))*1/2;
  
  // Affichage dans la console :

    Serial.print("===================================================================");
    Serial.println();

Serial.print("Pression mesurée : ");
    Serial.print(pression/100);
    Serial.print(" hPa");
    Serial.println();
    
    Serial.print("Temperature mesurée : ");
    Serial.print(moyenne_temperature);
    Serial.print(" K ou ");
    Serial.print(round(moyenne_temperature-273.15));
    Serial.print(" °C (moyenne entre ");
    Serial.print(temperature_kelvin_1);
    Serial.print(" K et ");
    Serial.print(temperature_kelvin_2);
    Serial.print(" K)");
    Serial.println();

    Serial.print("- - - - - - - - - - - - - -");
    Serial.println();

    Serial.print("Temperature calculée : ");
    Serial.print(calcul);
    Serial.print(" K");
    Serial.print(" (± ");
    Serial.print(incertitude);
    Serial.print(" K)");
    Serial.println();

    float temperature_plus = calcul+incertitude;
    Serial.print("Température plus : ");
    Serial.print(temperature_plus);
    Serial.print(" K");

 Serial.println();
    
    float temperature_moins = calcul-incertitude;
    Serial.print("Température moins : ");
    Serial.print(temperature_moins);
    Serial.print(" K");
    Serial.println();

    // Affichage à la ligne 1 de l'afficheur LED :

    lcd.setCursor(0,0);
    lcd.print("T=");
    lcd.print(round(moyenne_temperature));
    lcd.print("K P=");
    lcd.print(round(pression/100));
    lcd.print("hPa");

    Serial.print("- - - - - - - - - - - - - -");
    Serial.println();

    // Affiche la différence entre la température calculée et la température réelle mesurée
    
    Serial.print("Différence entre la température calculée et la température réelle mesurée : ");
    Serial.print(abs(calcul-moyenne_temperature));
    Serial.print(" K");
    Serial.println();

    Serial.print("- - - - - - - - - - - - - -");
    Serial.println();
    
    if (moyenne_temperature<temperature_plus and moyenne_temperature>temperature_moins){

 Serial.println();
    
    float temperature_moins = calcul-incertitude;
    Serial.print("Température moins : ");
    Serial.print(temperature_moins);
    Serial.print(" K");
    Serial.println();

    // Affichage à la ligne 1 de l'afficheur LED :

    lcd.setCursor(0,0);
    lcd.print("T=");
    lcd.print(round(moyenne_temperature));
    lcd.print("K P=");
    lcd.print(round(pression/100));
    lcd.print("hPa");

    Serial.print("- - - - - - - - - - - - - -");
    Serial.println();

    // Affiche la différence entre la température calculée et la température réelle mesurée
    
    Serial.print("Différence entre la température calculée et la température réelle mesurée : ");
    Serial.print(abs(calcul-moyenne_temperature));
    Serial.print(" K");
    Serial.println();

    Serial.print("- - - - - - - - - - - - - -");
    Serial.println();
    
    if (moyenne_temperature<temperature_plus and moyenne_temperature>temperature_moins){

    Serial.print("===================================================================");
    Serial.println();

   // Attente de 1 seconde avant de mettre à jour l' :
   
   delay(1000);
}

Goupe B Binome 1 : Wiki dessin

31/01/2022 - binôme 1 - Stephane Guangnenon et Tatiana Ranger

TRAVAIL DE GROUPE

Se familiariser avec le wiki

tuto et code sur autres project fablabs pour apprendre les entrees de code

1. en gras

2. en italique

3. souligné

4. barre

mettre en couleur : code couleur trouvé sur : https://www.code-couleur.com

rouge jaune cian vert rose

inserer une image : Sélectionner une image, la télécharger, puis insérer avec l'option directe.

Se familiariser avec les logiciels 2d et 3d

Réaliser une image type logo avec inskape à partir d'une image

Pour cela, commencer par insérer une image. Ensuite, il faut mettre cette image comme “layout” puis créer une deuxième “ layout” qui sera en fait votre logo. La fermeture et l'ouverture de chacune de ces couches, grace au cadenas, vous permet de visualiser lui ou l'autre ou les deux en meme temps.

Source image : https://www.animaw.com/comment-vit-le-grand-dauphin

Vidéo visionnée :

tuto : https://www.youtube.com/watch?v=s-kPg4vYKfk

Réalisation plan de construction de notre cube percé en 2D

Réaliser un carré de dimension 5cmx5cm en ligne rouge. Pour modifier la couleur, il faut utiliser l'option “skill and fill”, indiquer que vous ne voulez pas de remplissage mais une couleur de bordures. Ensuite, tracer 4 cercles identiques de diamètre 5mm.

Réaliser un cube percé sur FreeCAD :

Nous avons modélisé un cube, afin de prendre en main le logiciel FreeCAD.

1ère Étape : Faire une esquisse d'un carré avec l'option “créer une nouvelle esquisse”

2ème Étape : Créer le cube de 5cm de côté à partir de l'esquisse avec l'option “faire une protrusion de l'esquisse selectionnée”

3ème Étape : Percer le cube, pour cela utiliser l'option “créer un perçage à partir de l'esquisse sélectionnée”

On perce le cube avec des trous de 5cm de diamètre au centre de chaque faces. Le résultat :

4ème Étape : Imprimer le cube percé, nous avons utilisé l'imprimante 3D à disposition pour imprimer le résultat de notre modélisation

L'interface de l'imprimante :

La réalisation du cube :

Le résultat obtenu est plutôt satisfaisant :

Vidéos visionnées :

- tuto freecab pour le cube : https://www.youtube.com/watch?v=SPFoXfEAufw et https://www.youtube.com/watch?v=QccTpQOu8GI

- perçage : https://www.youtube.com/watch?v=BT0uG0NzERk

Se familiariser avec les capteurs Arduino

(Séance avec Reda du binôme 2)

Pour commencer, nous avons utilisé le site (https://wiki.seeedstudio.com/Grove-TempAndHumi_Sensor-SHT31/) qui nous a permis d'effectuer les branchements entre le capteur SHT31 et le port Arduino. Comme ceci :

Sur ce même site, on a obtenu le code permettant d'afficher les mesures du capteur d'humidité et de température, qu'on injecte dans le logiciel Arduino. Voir ci-dessous :

Le code nous renvoie les mesures du capteur, on appuie sur “téléverser” on attend qu'il finisse et on utilise l'outil “Moniteur série” qui affiche les valeurs ou “Traceur série” qui affiche son graphe au cours du temps. Voici les mesures obtenu :

Ensuite, nous avons testé le capteur de gaz HCHO à partir du site (https://wiki.seeedstudio.com/Grove-HCHO_Sensor/) Nous l'avons branché à l'Arduino :

Puis nous avons inséré le code du site :

Les valeurs obtenus sont les suivantes :

On observe que quand la quantité de gaz présent dans l'air augmente, les valeurs du capteurs diminuent.