# đ UE LU3ST062 - Atelier Fablab
Le stage "Fablab" propose à des équipes de 2 ou 3 étudiants de développer une approche de modélisation analogique et numérique autour d'un problÚme de Sciences de la Terre.
Le but est de mettre au point, améliorer et utiliser des maquettes (non-dimensionnées) puis des modÚles analogiques (dimensionnés) pour mettre en évidence un processus ou évaluer un paramÚtre critique. La discussion porte ensuite sur le passage des conclusions aux échelles géologiques.
ConcrÚtement la réalisation des montages passe par l'utilisation des ressources du Fablab (impression 3D, conception assistée par ordinateur ... ) et d'outils d'interfaçage (Arduino, MATLAB ... ) pour l'extraction de données des expériences.
# ModĂšle analogique sable
Kathy Lazard, Amaury Leroy, Dan Rebibo et Alice Saugrain
Partout sur notre planÚte, à des échelles variant de quelques centaines de mÚtres à des centaines de kilomÚtres, on peut observer nombre de fleuves avec chacun une dynamique qui leur est propre. Selon les pentes, la nature de leur substrat ou encore l'aménagement des territoires, les cours d'eaux varient. Cependant ils suivent tous des principes de sédimentologie et d'hydrologie. C'est ce que nous avons tenté de modéliser au cours de cette UE. Chaque semaine nous nous sommes réunis pour faire progresser notre modÚle analogique des réseaux fluviatiles. Nous nous sommes inspirés du modÚle existant produit par *EmRiver*, et nous avons cherché à le reproduire à moindre coût dans l'objectif d'utiliser cette table à des fins pédagogiques.
(fig 1)Table existante *EmRiver* modĂšle *em3*
*[https://emriver.com/beyond-the-stream-table-and-using-the-emriver-em2-geomodel-at-gsa-2014-vancouver/](https://emriver.com/beyond-the-stream-table-and-using-the-emriver-em2-geomodel-at-gsa-2014-vancouver/)*
[ \[1\]](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/gsa-2013-denver-little-river-reseach-and-design-em3-4291.jpg)
Pour cela nous sommes partis du cahier des charges suivant :
Notre table doit ĂȘtre :
- un support dâexercices pour des sĂ©ances de TP dâune durĂ©e de 3h niveau L1, rĂ©partis sur 1 semaine
- utilisable en petits groupes de 4/machine
- reproductible plusieurs fois, sans que le coût ne soit excessif
- un modÚle réduit déplaçable et démontable facilement
- équipée d'un systÚme hydrologique réparable et que l'on puisse brancher aisément
- équipée d'un systÚme d'eau en circuit fermé
Tout en gardant en tĂȘte ces attentes, nous avons dĂ» rĂ©flĂ©chir Ă des solutions pour minimiser les coĂ»ts et faire face aux problĂ©matiques que nous avons rencontrĂ© dans la conception de notre table. C'est ce que nous allons dĂ©velopper dans ce Wiki.
##### **Plan** **:**
**I.** **La conception de la table**
A/ La fabrication du bac
B/ Les modĂšles 3D
**II. Assemblage et tests**
**III.** **Utilisation du modĂšle**
Conclusion et perspectives
##### **I. La conception de la table.**
##### A/ La fabrication du bac.
-Etanchéité
AprÚs l'obtention de la table en bois conçu par Loïc Labrousse aux dimensions souhaités (75 x 50 x 10 cm), nous avons aussitÎt procédé à son bùchage dans le but de l'imperméabiliser. Pour ce faire, nous avons mis du scotch double face sur toute la surface interne de la table, avant de la recouvrir d'une bùche transparente. Bien que la bùche ne présentait aucune lacune, nous avons néanmoins veillé à vérifier l'efficacité de son action imperméabilisante en arrosant la table avec de grandes quantités d'eau et n'avons pas détecté de fuites (il s'est avéré par la suite qu'aprÚs plusieurs raclages, la bùche s'est abimée et a présenté 1 petit trou).
***(fig 2) Photographie de la table en bois aprĂšs bĂąchage :***
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/image-1683462148216.png)
-Angles de pente
Un des paramĂštres que l'on peut mesurer dans un tel modĂšle analogique est l'impact de la variation d'une pente sur les modalitĂ©s de formation d'un rĂ©seau fluviatile. Ainsi, dans un second temps, nous avons cherchĂ© Ă munir la table d'un dispositif de modulation de pente. EmRiver donnait des valeurs de pente allant de 0 Ă 3,5° pour ses modĂšles. Nous avons alors pensĂ© Ă fabriquer des pieds ajustables. Nous avons alors remplacĂ© les deux pieds en bois situĂ©s du cĂŽtĂ© de "l'orifice d'arrivĂ© d'eau" par deux pieds en bois de mĂȘme hauteur mais creux. L'objectif de ces derniers (que nous avons conçu nous mĂȘme) et de pouvoir y insĂ©rer une barre mĂ©tallique percĂ©e de trous, afin ultĂ©rieurement de pouvoir choisir le niveau de pente d'intĂ©rĂȘt. Il a fallu faire des trous supplĂ©mentaires dans la barre mĂ©tallique afin d'avoir plus de choix dans les valeurs d'angles.
Le problĂšme majeur que l'on a eu c'est qu'on ne peut pas faire un trou circulaire de 20cm de longueur dans du bois. Il a donc fallu faire des trous avec une scie-cloche et coller 10 rectangles de bois les uns sur les autres (avec de la colle Ă bois) pour faire la hauteur voulue.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/image-1676236888195.png)
Avant (fig 3a)
AprĂšs (fig 3b)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/img-6152.JPG)
Détail du pied et la barre d'acier à l'intérieur à insérer telle quelle, la partie la plus fine vers la table. La différence entre 2 trous correspond à un angle effectif de 0,86° sur la table.
***(fig 4) Schéma du dispositif de pieds ajustables (4a) et photographie de la face inférieure de la table montrant les pieds incrustés à la table (B) :***
***4a) 4b)***
[  ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/image-1683463454460.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/image-1683463617423.png)
Le résultat n'est pas trÚs esthétique mais ce principe de pieds ajustables nous apparait comme étant un moyen efficace et peu coûteux pour ajuster la pente de la table (plusieurs valeurs prédéfinies possibles). Tel que nous les avions conçu, les pieds actuellement présent sur la table offrent jusqu'à 6 cm de battement de pied (soit 3,5° de pente).
-Bac à décantation et circuit d'eau fermé
Dans un troisiÚme temps, nous nous étions lancé dans l'élaboration d'un bac à décantation. En effet, pour des raisons pratiques et écologiques, puis surtout pour permettre une pseudo-automatisation du modÚle, l'alimentation en eau se fait suivant un schéma de circuit fermé. L'eau se jette dans la table, traverse le sable, puis doit pouvoir sortir au niveau de "l'orifice d'évacuation". Il faut donc, au débouché, un dispositif capable de réceptionner cette eau et les particules "sédimentaires" entrainées. Une fois réceptionnée (bac de décantation), l'eau (sans les particules, dorénavant décantées) est alors conduite vers un autre bac qui comporte la pompe (bac à pompe). La pompe absorbe alors l'eau et la conduit à nouveau en direction de l'orifice d'arrivée d'eau (et ainsi de suite).
***(fig 5) Schéma simplifié illustrant la circulation de l'eau dans le systÚme (circuit fermé) :***
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/image-1683466376693.png)Pour ce faire, nous nous étions munis de deux bidons d'eau déminéralisée vides, puis les avions fait se communiquer à mi hauteur via un tube creux métallique (pour permettre seulement à l'eau de transiter du bac de décantation vers le bac à pompe, dans l'objectif de permettre une alimentation en eau automatique de la pompe).
***(fig 6) Photographie du dispositif "Bac de décantation "-"Bac à pompe" :***
Bac à pompe Bac à décantation
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/image-1683466541039.png)
Avant d'entreprendre un premier essai du modĂšle, nous avions Ă©valuĂ© la fonctionnalitĂ© et la qualitĂ© de la pompe mise Ă notre disposition. Il en rĂ©sultait que la pompe fonctionne et qu'elle a deux dĂ©bits possibles. Nous avions alors dĂ©cidĂ© d'utiliser cette pompe, et l'avions donc munie dâun Ă©pais tube de polyurĂ©thane pour lui permettre de propulser et de dĂ©livrer l'eau jusqu'Ă l'orifice d'arrivĂ© d'eau. Par la suite, on aura vite fait de s'apercevoir que le dĂ©bit de la pompe et par nature bien trop fort. Les derniĂšres expĂ©riences seront alors rĂ©alisĂ©es avec le tube de polyurĂ©thane pincĂ© entre les deux bras d'un Ă©tau.
##### B/ Les modĂšles 3D
Pour minimiser les coûts (et acquérir de nouvelles compétences), nous avons codé plusieurs piÚces avec le logiciel *Openscad* pour les imprimer au FabLab.
Voici la liste des piÚces que nous avons codé et imprimé :
1. Entrée d'eau : 2 piÚces, un bec verseur et une piÚce connectée au tuyau et fixée dans la planche (fig 7)
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/ineleph.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/pharynx.png)
2. Energy Dissipator Unit (EDU), piÚce qui réceptionne l'eau sortant du bec verseur et diminue donc son énergie cinétique. (fig 8)
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/screenshot-2023-05-06-173304.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/screenshot-2023-05-06-173338.png)
3. Sortie d'eau : 2 piÚces, une fixée au fond du bac et une interne dont le coulissement sert à faire varier le niveau d'eau du delta. (fig 9)
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/screenshot-2023-05-06-173816.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/screenshot-2023-05-06-173848.png)
Les fichiers STL sont joints Ă ce Wiki.
Nous avons fait face à plusieurs difficultés dans le codage et les impressions de ces piÚces : fragilité à l'impression, dimensions incompatibles, code effacé, ...
Pour la piÚce de sortie d'eau, nous avons fait face à des difficultés de codage du filetage. Le but de cette piÚce étant de ressembler à une vis, afin que un tour complet augmente ou diminue de 1cm la hauteur de l'eau accumulée dans le delta, nous avons codé le pas de vis mais le rendu était beaucoup trop fin pour résister aux forces qui allaient s'appliquer dessus.
En effet, nous voulions d'abord le coder en utilisant la fonction *spiral\_extrude* : grossiĂšrement, cette fonction utilise une forme en 2D (ici, nous voulions utiliser un cercle) et empile des copies de cette forme pour former une piĂšce en 3D. On peut faire s'enrouler cette structure autour d'un axe, c'est ce que nous pensions faire.
Seulement, la forme 3D est alors créée en empilant des formes 2D légÚrement décalées les unes par rapport aux autres. De ce fait, plus la piÚce s'enroule, plus le filetage est fin car les formes 2D se recouvrent moins. Utiliser la fonction *linear\_extrude* produit donc un filetage trÚs fin et fragile, qui de plus coulisse mal.
Il a donc fallu trouver une autre fonction sur Internet : la fonction *spiral\_extrude*, qui fonctionne de maniÚre similaire à *linear\_extrude* mais permet aussi de choisir l'épaisseur du filetage. Néanmoins, nous avons cette fois-ci eu des problÚmes à l'impression, les piÚces n'étaient pas assez solides et ont cassé dÚs que nous avons tenté de les utiliser.
Pour l'entrée d'eau nous avions initialement pensé à une piÚce de ce type : (fig 10)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/screenshot-2023-05-06-173110.png)
Cependant aprĂšs rĂ©flexion nous avons pensĂ© que l'eau n'aurait peut-ĂȘtre pas assez du puissance pour remonter le "robinet" et ce n'est pas le plus efficace non plus pour contrĂŽler la sortie d'eau. Nous avons donc modifiĂ© le design pour obtenir les 2 piĂšces suivantes : (fig 11)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/totentree.png)
Elles sont emboßtables et l'une peut tourner grùce à un systÚme de complémentarité à l'intérieur.
Pour les piĂšces de sortie d'eau, la fragilitĂ© de la poignĂ©e nous a amenĂ© Ă utiliser tout le long de l'UE une version sans poignĂ©e qui, au final, Ă©tait tout aussi pratique. Par ailleurs, Ă cause de la dilatation du plastique Ă lâimpression nous avons dĂ» agrandir les trous de la table. Ce paramĂštre est Ă prendre en compte avant dâimprimer les piĂšces.
[ (fig 12)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-03/2dc26e40-1ff0-4f9b-8aa6-6e6ff5a1c30c.jpeg)
#####
##### **II. Assemblage et tests**
-Le 'sable' et ses proportions
Le 'sable' qui nous a été fourni par Loic Labrousse n'est pas du vrai sable mais des pastilles de plastique de différentes couleurs associées à différentes tailles, vendues par EmRiver. Ce 'sable' étant trÚs cher nous avons voulu essayer avec du sable quartz de Fontainebleau. Mais l'esthétique du 'sable' était beaucoup plus intéressant.
Dimensions et quantité de chaque couleur :
Tailles annoncées par EmRiver
Jaune : 1,4 mm de diamĂštre. Blanc : 1 mm. Noir : 0,7 mm. Rouge : 0,4 mm.
Dimensions réelles :
Jaune : majorité supérieure à 1,4, et les plus petits ne passent pas le filtre à 630 micromÚtres = à peu prÚs la bonne taille.
Blanc : 50% de plus grand que 630 micromÚtres, 50% entre 630 et 425. = plus petit que prévu (1 mm).
Noir : majorité entre 630 et 425 = plus petit que prévu (0,7).
Rouge : plus petit que prévu, avec 90% environ entre 250 et 200 micromÚtres.
-Quantités à disposition
Jaune : 1,63 kg
Blanc : 16,25 kg
Noir : 7,8 kg
Rouge : 1,12 kg
Dans les expériences les particules les plus GROSSES partaient en premier illustrant l'effet Granola ou effet de fond de transport des particules.
Nous avons fait un mélange assez arbitraire des couleurs mais le résultat était assez joli. Nous voyions bien les méandres et visualisions bien les alternances de couleurs dans les coupes du delta et du lit de la riviÚre.
**Mélange utilisé :**
Jaune : 1,63 kg (tout le paquet)
Blanc : 6,65 kg
Noir : 1,55 kg
Rouge : 0,78 kg
Poids total de sable utilisé : 10,61 kg
**(fig 13) Montage réel, avec dispositif permettant de filmer d'au-dessus de la table :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/4R1img-7551.JPG)
Nous voyions et visualisions bien les méandres, les alternances de couleurs dans les coupes du delta et du lit de la riviÚre.
Le 'sable' qui nous a été fourni par Loïc Labrousse n'est pas du vrai sable mais des pastilles de plastique de différentes couleurs associées à différentes tailles, vendues par EmRiver. Ce 'sable' étant trÚs cher, nous avons voulu essayer avec du sable de Fontainebleau pour minimiser les coûts. Mais l'esthétique du plastique était beaucoup plus intéressante.
**(fig 14) Comparaison sable de Fontainebleau et sable plastique**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/img-6785.JPG) vs. [](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/img-7074.jpg)
Nous avons laissĂ© lâeau se creuser elle-mĂȘme son lit, ce qui a donnĂ© des rĂ©sultats de mĂ©andres diffĂ©rents Ă chaque fois.
*(fig 15) Photos de différents tests*
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/Wkjimg-7832.JPG)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/img-7085.JPG)[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/img-7085.JPG)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/img-7460.JPG)[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/img-7460.JPG)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/img-7081.JPG)
Nous avons aussi essayĂ© uniquement avec du blanc et du noir en gardant la mĂȘme proportion de blanc, vu que c'est celui qui part en 1er. Les mĂ©andres se voyaient bien, presque mieux, mais les coupes dans le delta Ă©taient nettement moins pertinentes.
Lien Youtube pour voir des vidéos en timelapse : [https://www.youtube.com/@Fablabsable](https://www.youtube.com/@Fablabsable/featured)
Verdict : il faut au moins 3 couleurs, le rouge n'est pas forcément nécessaire (sauf si vous voulez des méandres plus beaux).
**Remarques :**
Le problĂšme de la pompe max 1000L/h : dĂ©bit trop puissant mĂȘme au minimum. Nous avons achetĂ© une pompe Ă 200L/h mais dĂ©bit non rĂ©gulier ce qui la rend inutile. Nous sommes donc restĂ©s avec notre pompe initiale,nous avons serrĂ© le tuyau avec plusieurs pinces et au final avons carrĂ©ment utilisĂ© un Ă©tau pour un meilleur contrĂŽle du dĂ©bit.
(fig 16) Référence de la pompe :
Table pas droite : mettre du papier sous le pied du cÎté plus bas et vérifier avec le niveau à bulle.
On a résolu de tasser les bords pour éviter que la riviÚre ne se jette d'un coté de la table et qu'elle puisse faire plus facilement des méandres.
La table fuit aux jointures : mettre un bac sous la table pour récolter l'eau fuyarde.
Une inclinaison maximale de la table a donné de bon résultats au niveau de l'écoulement d'eau c'est pourquoi nous préconisons de régler les pieds aux trous les plus hauts (3,5° de pente).
Tentative d'imperméabiliser avec du plastique thermoformant infructeuse car rendu trÚs gondolé. Tentative de pochoir à méandre infructueuse car tasse le sable.
##### **III.** **Utilisation du modĂšle**
Mode d'emploi :
**(fig 17) Schéma du dispositif entier**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/image-1683545839637.png)
Voici Ă©noncĂ© sous forme de notice la façon dont notre prototype sâutilise.
Il peut ĂȘtre utilisĂ© comme instructions pour un TP.
1- Placer le bac de dĂ©cantation (bac avec la plus grande ouverture) sous la sortie dâeau. Veiller Ă ce que le bac Ă pompe qui lui est associĂ© soit sous la table mais accessible pour placer et manipuler la pompe. Placer donc la pompe.
2- Humidifier le sable en versant 4,5 L dâeau en plusieurs fois, et ce, prĂšs de lâentrĂ©e dâeau dans le bac.
3- MĂ©langer le sable pour homogĂ©nĂ©iser la granulomĂ©trie Ă lâĂ©chelle du bac. Attention, NE PAS LE TASSER !
4- Tasser le sable localisĂ© au niveau des 5 cm les plus proches des bords latĂ©raux de la table : cela permettra de maintenir le cours dâeau loin des bords de la table.
5- Aplanir le reste du sable (celui encadrĂ© par les 5 cm tassĂ©s Ă lâĂ©tape 4), et ce, SANS LE TASSER. En effet, il est crucial de laisser une certaine hĂ©tĂ©rogĂ©nĂ©itĂ©. Veiller Ă laisser une zone sans sable dâenviron 25 cm du cĂŽtĂ© de la sortie dâeau : elle reprĂ©sentera le delta (le passage âcontinentâ - âdeltaâ doit ĂȘtre progressif).
(fig 18)
6- Placer lâEDU et lâentrĂ©e dâeau, de maniĂšre Ă ce que le bec de lâentrĂ©e dâeau soit posĂ© sur le cylindre central de lâEDU. Si besoin, tasser du sable sous lâEDU pour le surĂ©lever, afin que la sortie de lâEDU soit au niveau de la surface du sable.
(fig 19)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/img-7830.JPG)
7- Verser 9L dâeau dans le bac de dĂ©cantation Ă travers la sortie dâeau (utiliser un entonnoir). Verser en plusieurs fois, cela donnera le temps Ă lâeau de passer du bac de dĂ©cantation au bac de la pompe, Ă©vitant ainsi tout dĂ©bordement !
8- RĂ©gler la pente via les pieds ajustables de la table. VĂ©rifier que les pieds sont Ă la mĂȘme hauteur.
9- Placer le dispositif vidĂ©o au-dessus de la table, de telle sorte que toute la table puisse ĂȘtre filmĂ©e.
10- VĂ©rifier que la table nâest pas penchĂ©e, en haut comme en bas, Ă lâaide dâun niveau de gĂ©omĂštre : la moindre variation peut avoir beaucoup dâeffet ! Si besoin, placer des cales (en papier, ça suffit) sous les pieds jusquâĂ ce que la bulle du niveau se trouve bien au centre.
11- Serrer lâĂ©tau pour avoir un dĂ©bit de 10 mL/seconde (0,5 cm dâĂ©cartement).
(fig 20)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/c9ximg-8522.JPG)
*Dispositif de serrage du tuyau avec un Ă©tau.*
12bis- 2 choix :
a- Laisser lâeau se faire son chemin -> ne rien faire
b- Suivre l'Ă©volution dâun mĂ©andre -> prĂ© tracer un chemin dans le sable
13- Lancer lâexpĂ©rience en branchant la pompe. Câest parti !
14- Lorsque votre expérience est conclue, débrancher la pompe.
15- Laisser lâeau du delta sâĂ©vader dans le bac de dĂ©cantation (attendre 5 minutes). Pas dâinquiĂ©tudes si du sable est emportĂ©.
16- Sâil vous lâest demandĂ©, rĂ©aliser des coupes.
17- Retirer de la table le tuyau dâalimentation en eau.
18- Retirer lâeau du bac de dĂ©cantation.
19- Ajuster les pieds de la table de sorte que le pendage soit nul.
20- MĂ©langer grossiĂšrement le sable, de sorte que le groupe suivant puisse dĂ©buter lâexpĂ©rience avec un sable hĂ©tĂ©rogĂšne et sans avoir connaissance du rĂ©sultat attendu.
##### ***Conclusion et perspectives***
Notre objectif avec ce projet Ă©tait de concevoir un systĂšme de modĂ©lisation de rĂ©seau fluviatile pour un coĂ»t plus raisonnable que le modĂšle EmRiver. Il devait ĂȘtre suffisamment petit pour ĂȘtre utilisĂ© en plusieurs exemplaires dans la mĂȘme salle de classe, mais assez grand pour ĂȘtre observable par un groupe de 4 Ă©lĂšves ; lâeau et le âsableâ devaient ĂȘtre conservĂ©s dans le systĂšme avec un circuit fermĂ©.
Tout dâabord, au terme de ce projet, nous avons une expĂ©rience qui fonctionne et nous pouvons observer des phĂ©nomĂšnes intĂ©ressants avec.
Nous avons dâabord utilisĂ© une table en bois de 75 x 50 x 10 cm, bĂąchĂ©e pour Ă©viter la dĂ©formation et les fuites mais nous pensons quâutiliser une table plus grande, de 120 x 60 x 15 cm serait plus judicieux, pour pouvoir former plus de mĂ©andres (plus de sable que ce que nous avons utilisĂ© sera nĂ©cessaire).
Pour amĂ©liorer la table/bac, utiliser un autre matĂ©riau pourrait contrer les problĂšmes d'Ă©tanchĂ©itĂ© : plexiglass sur mesure (solide, impermĂ©able, transparent, mais dâautant plus cher que des plaques de 8 mm dâĂ©paisseur seraient idĂ©ales), bac en plastique (moins esthĂ©tique mais beaucoup moins coĂ»teux) ou garder du bois mais peint, verni ou avec une bĂąche de qualitĂ© (bĂąche ETM par exemple). Acheter des pieds ajustables similaires Ă ceux que nous avons fabriquĂ©s seraient aussi indiquĂ©.
La circulation dâeau pourrait elle aussi ĂȘtre amĂ©liorĂ©e, notamment selon deux aspects. PremiĂšrement, la pompe que nous utilisons est Ă dĂ©bit trop important et inconstant : la remplacer par une pompe plus petite et/ou ajouter un dĂ©bit-mĂštre rĂ©glable pour contrĂŽler finement le dĂ©bit serait utile. En second lieu, le systĂšme de dĂ©cantation Ă deux bacs fonctionne bien mais il est difficile de rĂ©cupĂ©rer le sable car celui-ci est mouillĂ© ou collĂ© aux parois. Une solution serait de placer un grillage horizontal assez haut dans le premier bac, de maniĂšre Ă retenir le sable au-dessus du niveau de lâeau et ainsi lui permettre de sĂ©cher.
Enfin, les impressions 3D sont fonctionnelles et suffisantes, mais souvent peu solides ; nous pourrions les imprimer en rĂ©sine mais les dĂ©formations Ă©ventuelles risquent dâempĂȘcher certaines piĂšces dâĂȘtre complĂ©mentaires. RĂ©imprimer lâEDU avec une fente externe moins longue pourrait aussi ĂȘtre utile mais pas nĂ©cessaire, tout comme raccourcir la sortie dâeau.
**Bibliographie**
\[1\] « Emriver Stream Tables & Hydraulic Flumes ». *Emriver*, https://emriver.com/.
**Remerciements**
Un grand merci à Loic Labrousse et à Pierre Théry qui nous ont aidé et encadré tout au long du projet. Merci également a Damien Do Couto qui nous a fait un retour sur la manip et sur son utilisation possible en TP. Merci aussi à l'équipe du Fablab Polytech qui nous a appris à utiliser les imprimantes 3D pour les impressions de piÚces.
Carnet de bord
SĂ©ance 0 (vendredi 20 janvier) :
PrĂ©sentation de lâUE et du projet sable.
Nous avons visité le fablab puis nous avons fait un brainstorming sur comment concevoir la table et son systÚme hydraulique avec les différents paramÚtres à prendre en compte.
**SĂ©ance 1 (vendredi 27 janvier) :**
TEST 1
â bac Ă tester en bois recouvert bĂąche, connaĂźtre dimensions idĂ©ales et syst hydro ouvert
pbm : avec la quantitĂ© de sable, quelle Ă©paisseur ? Est-ce quâon voit assez de phĂ©nomĂšne avec cette Ă©paisseur ?
rapports L/l de la boßte pour optimiser les phénomÚnes ?
Savoir le volume de sable quâon a et celui nĂ©cessaire. -> Taille de la boĂźte.
Avoir notre propre grille de tailles de grains (savoir la granulométrie de chaque type de grain).
IdĂ©e finale : savoir les dimensions de la boĂźte quâon va prendre.
Il nous fallait faire une révision du diamÚtre des sables mis à notre disposition, en vue de vérifier si les valeurs fournies par le site sont en adéquation avec ce que nous disposons (rapport qualité).
Jaune : 1,4 mm de diamĂštre.
Blanc : 1 mm.
Noir : 0,7 mm.
Rouge : 0,4 mm.
Toutes les particules ont la mĂȘme masse volumique, Ă©gale Ă 1,5 g/mL.
Donc si on prend une table de 75\*50 centimĂštres, il faut 28,125 kg de sable.
Rouge : plus petit que prévu, avec 90% environ entre 250 et 200 micromÚtres.
Noir : majorité entre 630 et 425 = plus petit que prévu (0,7).
Blanc : 50% de plus grand que 630 micromÚtres, 50% entre 630 et 425. = plus petit que prévu (1 mm).
Jaune : majorité supérieure à 1,4 et les plus petits ne passent pas le filtre à 630 micromÚtres = à peu prÚs la bonne taille.
Donc au sein de la mĂȘme couleur, on a une granulomĂ©trie hĂ©tĂ©rogĂšne.
De plus, la plupart des grains sont globalement plus petits que les valeurs données (tout sauf le jaune).
La courbe granulomĂ©trique qui a rĂ©sultĂ© de la sĂ©ance nâest pas assez prĂ©cise car nous nous intĂ©ressions seulement Ă oĂč s'arrĂȘtait la majoritĂ© des grains.
objectifs séance 2 :
-Avec un prototype de bac, tester les Ă©coulements dâeau pour savoir lâĂ©paisseur de sable Ă mettre
-Il faudrait re-tamiser les différents sables pour pouvoir faire notre propre courbe granulométrique en cumulé (les tailles de grains observées diffÚrent de celles indiquées).
**Séance 2 (vendredi 3 février) :**
- Etanchéité du bac (Kathy + Dan)
Loic Labrousse nous a fait un prototype de table pour tester les Ă©coulements dâeau. La prioritĂ© a Ă©tĂ© de rendre la table Ă©tanche. AprĂšs avoir mesurĂ© toute la surface du bac Ă couvrir et donc les dimensions de la bĂąche Ă utiliser, nous avons collĂ© du scotch double face pour coller la bĂąche sur la table. Cela nous a pris plus de temps que prĂ©vu en raison de la prĂ©caution lors de lâutilisation du scotch double face, les points les plus critiques Ă Ă©tanchĂ©ifier Ă©tant les angles.
Avant
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/image-1675707602212.JPG)
AprĂšs
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/image-1675707583469.JPG)
Lâautre possibilitĂ© est dâavoir directement une table en plexiglass ce qui ĂŽterait cette Ă©tape d'Ă©tanchĂ©ification mais ça coĂ»te cher.
Il nây a plus quâĂ tester vraiment la table avec de lâeau la semaine prochaine.
Selon le site emriver.com qui prĂ©sente les modĂšles dont nous nous inspirons en version cheap, l'angle dâinclinaison de la table est de 3 degrĂ© et celui-ci doit pouvoir varier entre 0 et 3,5. Ce qui veut donc dire quâon doit pouvoir surĂ©lever un cĂŽtĂ© de la table jusquâĂ 6 cm environ. Donc lâautre objectif de la prochaine sĂ©ance sera de voir comment on pourra le faire.
- Création des piÚces pour entrée et sortie d'eau (Alice + Amaury)
Pendant cette sĂ©ance nous avons aussi dĂ©couvert le logiciel Openscad avec lequel nous avons tentĂ© de crĂ©er le systĂšme de sortie dâeau du bac. LâidĂ©e Ă©tait de faire une sorte de vis creuse que lâon ferait tourner dâun tour (360°) pour modifier la hauteur de 1cm. Le trou dâĂ©vacuation dâeau Ă©tant au bout de cette vis, cela permet donc de modifier et contrĂŽler la hauteur dâeau au niveau de la zone du delta. La premiĂšre version du code est la suivante :
SORTIE D'EAU (cliquer sur le triangle pour voir le code)
// valeurs vis externe
color1 = "LightBlue"
h0 = 100
r0 = 22
fn = 36
tr2 =
// vis externe
difference(){
union(){
color(color1) cylinder(h0, r0, r0, true, $fn = fn);
translate(\[0, 0, 49\]) color(color1) cylinder(2.9, 28, 28, true, $fn = 36);
translate(\[0, 0, -62.5\]) color(color1) cylinder(25, 16, 22, true);
translate(\[0, 0, -87.5\]) color(color1) cylinder(25, 16, 16, true);
}
cylinder(101, 19, 19, true, $fn = 36);
translate(\[0, 0, -62.5\]) cylinder(26, 13, 19, true);
translate(\[0, 0, -87.5\]) cylinder(26, 13, 13, true);
linear\_extrude(height = 100, center = true, convexity = 10, twist = 3600)
translate(\[20, 0, 0\]) circle(r = 1.5);
}
// vis interne
difference(){
union(){
translate(\[0, -17.5, 70\]) color("Pink") cylinder(30, 1.5, 1.5, true);
translate(\[0, 0, 85\]) rotate(a=\[90, 90, 0\]) color("Pink") cylinder(38, 1.5, 1.5, true);
translate(\[0, 17.5, 70\]) color("Pink") cylinder(30, 1.5, 1.5, true);
translate(\[0, 0, 2.5\]) color("Pink") cylinder(105, 19, 19, true, $fn = 36);
// cylinder(100, 21.3, 21.3, true, $fn = 36);
linear\_extrude(height = 100, center = true, convexity = 10, twist = 3600, $fn = 36) translate(\[20, 0, 0\]) circle(r = 1.3);
}
translate(\[0, 0, 2.5\]) cylinder(106, 16, 16, true, $fn = 36);
linear\_extrude(height = 100, center = true, convexity = 10, twist = 3600, $fn = 36) translate(\[20, 0, -2.6\]) rotate(\[90, 0, 0\]) circle(r = 1.3);
}
//CODE NECESSAIRE POUR IMPRIMER LES 2 PIECES
//valeurs générales
colorext= "LightBlue";
colorint= "Pink";
fn= 36;
//On notera que ces 3 valeurs ne servent qu'à l'aspect visuel : la couleur ne sera pas nécessaire à l'impression, et la définition permettra un rendu plus harmonieux (et des cercles plus ... ronds).
//valeurs gros cylindre (servent de base Ă toutes les autres valeurs, surtout hbigtube)
hbigtube= 100;
rbigtube= 0.22\*hbigtube;
//valeurs vide gros cylindre
hemptybigtube =1.01\*hbigtube;
remptybigtube= 0.19\*hbigtube;
twistroom= 9\*hemptybigtube;
//explication : on veut que pour accueillir la crĂȘte de la vis, la rainure ( "room" dans les noms de valeurs) fasse toute la longueur du gros cylindre ("bigtube"). Donc on aurait twistroom= 5.4 (parce que 540° de twist)\*hbigtube.
// Sauf que le cylindre plat au sommet ("toptube") est posĂ© lĂ©gĂšrement plus haut que le sommet du "bigtube" ... mais pas de problĂšme ! Le tube de vide qui les rend creux ("emptybigtube") est plus grand que le "bigtube" pour rendre "bigtube" et "toptube" creux en mĂȘme temps :)
// RĂ©sultat des courses : hroom = hemptybigtube permet de se simplifier la vie, en donnant hroom = 101 alors que h(bigtube+toptube)= 100.9. Ceci Ă©tant fait, on doit Ă©viter de perdre en prĂ©cision sur la rainure : en calculant le twist sur hemptybigtube, on peut garder le twist propotionnel Ă la taille des tubes, donc toujours la mĂȘme ligne comparativement au tube.
conv= 10;
//CODE NECESSAIRE EN PLUS POUR IMPRIMER LE SUPPORT
//valeurs piĂšce externe (support)
//valeurs top cylindre
transxtoptube= 0;
transytoptube= 0;
transztoptube= 0.49\*hbigtube;
htoptube= 0.029\*hbigtube;
rtoptube= 0.28\*hbigtube;
//valeurs cĂŽne et petit tube
transxcone= 0;
transycone= 0;
transzcone= -0.625\*hbigtube;
hcone= 0.25\*hbigtube;
rconelow= 0.16\*hbigtube;
rconetop= 0.22\*hbigtube;
transxsmolcone= 0;
transysmolcone= 0;
transzsmolcone1= -0.79\*hbigtube;
transzsmolcone2= -0.87\*hbigtube;
transzsmolcone3= -0.95\*hbigtube;
hsmolcone1= 0.08\*hbigtube;
hsmolcone3= 0.09\*hbigtube;
rsmolconetop= 0.16\*hbigtube;
rsmolconelow1= 0.15\*hbigtube;
rsmolconelow3= 0.14875\*hbigtube;
//valeurs vide gros cylindre (les pas fondamentales)
transxemptybigtube= 0;
transyemptybigtube= 0;
//valeurs vide cĂŽne et vide petit tube
hemptycone= 0.26\*hbigtube;
remptyconelow= 0.13\*hbigtube;
remptyconetop= 0.19\*hbigtube;
hemptysmolcone= 0.26\*hbigtube;
remptysmolcone= 0.13\*hbigtube;
//Valeurs rainure d'insertion vis ("room")
hroom= hemptybigtube;
transxroom1= 0.19\*hbigtube;
transxroom2= -transxroom1;
transyroom= 0;
transzroom= 0;
rroom= 0.017\*hbigtube;
// piĂšce externe (support)
difference(){
union(){
color(colorext) cylinder(hbigtube, rbigtube, rbigtube, true, $fn = fn);
translate(\[transxtoptube, transytoptube, transztoptube\]) color(colorext) cylinder(htoptube, rtoptube, rtoptube, true, $fn = fn);
translate(\[transxcone, transycone, transzcone\]) color(colorext) cylinder(hcone, rconelow, rconetop, true, $fn= fn);
translate(\[transxsmolcone, transysmolcone, transzsmolcone1\]) color(colorext) cylinder(hsmolcone1, rsmolconelow1, rsmolconetop, true, $fn= fn);
translate(\[transxsmolcone, transysmolcone, transzsmolcone2\]) color(colorext) cylinder(hsmolcone1, rsmolconelow1, rsmolconetop, true, $fn= fn);
translate(\[transxsmolcone, transysmolcone, transzsmolcone3\]) color(colorext) cylinder(hsmolcone3, rsmolconelow3, rsmolconetop, true, $fn= fn);
}
cylinder(hemptybigtube, remptybigtube, remptybigtube, true, $fn = fn);
translate(\[transxcone, transycone, transzcone\]) cylinder(hemptycone, remptyconelow, remptyconetop, true, $fn= fn);
translate(\[transxcone, transycone, transzsmolcone2\]) cylinder(hemptysmolcone, remptysmolcone, remptysmolcone, true, $fn= fn);
linear\_extrude(height = hroom, center = true, convexity = conv, twist = twistroom, $fn= fn) translate(\[transxroom1, transyroom, transzroom\]) circle(r = rroom);
linear\_extrude(height = hroom, center = true, convexity = conv, twist = twistroom, $fn= fn) translate(\[transxroom2, transyroom, transzroom\]) circle(r = rroom);
}
//CODE NECESSAIRE EN PLUS POUR IMPRIMER LA VIS
//valeurs piĂšce interne (vis)
//valeurs cylindres anse
transxlattube= 0;
transylefttube= 0.175\*hbigtube;
transyrighttube= -transylefttube;
transzlattube= 0.7\*hbigtube;
transxmidtube= 0;
transymidtube= 0;
transzmidtube= 0.85\*hbigtube;
rotxmidtube= 90;
rotymidtube= 90;
rotzmidtube= 0;
hlattube= 0.3\*hbigtube;
rlattube= 0.03\*hbigtube;
hmidtube= 0.4\*hbigtube;
rmidtube= 0.03\*hbigtube;
//valeurs gros cylindre interne
transxbigint= 0;
transybigint= 0;
transzbigint= 0.025\*hbigtube;
hbigint= 1.05\*hbigtube;
rbigint= 0.19\*hbigtube;
//valeurs crĂȘte vis
hvis= hbigtube;
rotxvis= 0;
rotyvis= 0;
rotzvis= -4;
transxvis1= 0.19\*hbigtube;
transxvis2= -transxvis1;
transyvis= 0;
transzvis= 0;
rvis= 0.013\*hbigtube;
//valeurs vide gros cylindre interne
transxemptybigint= 0;
transyemptybigint= 0;
transzemptybigint= 0.025\*hbigtube;
hemptybigint= 1.06\*hbigtube;
remptybigint= 0.16\*hbigtube;
// piĂšce interne (vis)
difference(){
union(){
translate(\[transxlattube, transyrighttube, transzlattube\]) color(colorint) cylinder(hlattube, rlattube, rlattube, true, $fn= fn);
translate(\[transxlattube, transylefttube, transzlattube\]) color(colorint) cylinder(hlattube, rlattube, rlattube, true, $fn= fn);
translate(\[transxbigint, transybigint, transzmidtube\]) rotate(a=\[rotxmidtube, rotymidtube, rotzmidtube\]) color(colorint) cylinder(hmidtube, rmidtube, rmidtube, true, $fn= fn);
translate(\[transxbigint, transxbigint, transzbigint\]) color(colorint) cylinder(hbigint, rbigint, rbigint, true, $fn = fn);
rotate(\[rotxvis, rotyvis, rotzvis\]) linear\_extrude(height = hvis, center = true, convexity = conv, twist = twistroom, $fn = fn) translate(\[transxvis1, transyvis, transzvis\]) circle(r = rvis);
rotate(\[rotxvis, rotyvis, rotzvis\]) linear\_extrude(height = hvis, center = true, convexity = conv, twist = twistroom, $fn = fn) translate(\[transxvis2, transyvis, transzvis\]) circle(r = rvis);
}
translate(\[transxemptybigint, transyemptybigint, transzemptybigint\]) cylinder(hemptybigint, remptybigint, remptybigint, true, $fn = fn);
}
**ENTREE D'EAU**
//aucune idée des diamÚtres de tuyaux donc il faudra soft-coder les diam des cylindres pour ajuster selon le tuyau mais en gros j'pense c'est pas mal
union(){
difference(){
rotate(\[0, 65, 0\])cylinder(40, 5, 12);
translate(\[-1, 0, 0\])rotate(\[0, 65, 0\])cylinder(42, 3, 10);
translate(\[45, 0, -24\])cylinder(52, 10, 10);}
difference(){
translate(\[30, 0, 15.5\]) rotate(\[0, 90, 0\])cylinder (30, 12, 12);
translate(\[29, 0, 15.5\]) rotate(\[0, 90, 0\])cylinder(30, 9, 9);
translate(\[45, 0, -27.5\])cylinder(48, 10, 10);}
}
difference(){
translate(\[45, 0, -23\])cylinder(50, 12, 12);
translate(\[45, 0, -24\])cylinder(52, 10, 10);
translate(\[29, 0, 15.5\]) rotate(\[0, 90, 0\])cylinder(32, 10, 10);}
fn = 90;
rtube = 12.5;
htube = 50;
r1cone = 12.5;
r2cone = 5.5;
hcone = 10;
transzcone = 30;
hpetitcone = 8;
r1petitcone = 5;
r2petitcone = 5.5;
transzpetitcone1 = 38;
transzpetitcone2 = 46;
transzpetitcone3 = 54;
rvidetube = 10.5;
hvidetube = htube + 1;
transzvidetube = -0.99;
r1videcone = 10.5;
r2videcone = 3.5;
hvidecone = hcone + 1;
transzvidecone = 28.5;
rvidepetitcone = 4;
hvidepetitcone = 3\*hpetitcone+1.1;
transzvidepetitcone = 46;
transxcle = 12.5;
transzcle = -21.5;
hcle = 3;
rcle = 2;
difference(){
union(){
cylinder(htube, rtube, rtube, true, $fn = fn);
translate(\[0, 0, transzcone\]) cylinder(hcone, r1cone, r2cone, true, $fn = fn);
translate(\[0, 0, transzpetitcone1\]) cylinder(hpetitcone, r2petitcone, r1petitcone, true, $fn = fn);
translate(\[0, 0, transzpetitcone2\]) cylinder(hpetitcone, r2petitcone, r1petitcone, true, $fn = fn);
translate(\[0, 0, transzpetitcone3\]) cylinder(hpetitcone, r2petitcone, r1petitcone, true, $fn = fn);
translate(\[transxcle, 0, transzcle\]) cylinder(hcle, rcle, rcle, true, $fn = fn);
}
translate(\[0, 0, transzvidetube\]) cylinder(hvidetube, rvidetube, rvidetube, true, $fn = fn);
translate(\[0, 0, transzvidecone\]) cylinder(hcone, r1cone, r2cone, true, $fn = fn);
translate(\[0, 0, transzvidepetitcone\]) cylinder(hvidepetitcone, rvidepetitcone, rvidepetitcone, true, $fn = fn);
}
fn = 36;
htubeext = 50;
rtubeext = 25;
htubeint = 35;
rtubeint = 15;
hbase = 2;
transzbase = -2;
rbase = rtubeext;
hvidetubeext = 51;
rvidetubeext = 23;
transzvidetubeext = -0.5;
hvidetubeint = 36;
rvidetubeint = 13;
transzvidetubeint = -0.5;
rsphere = 3.5;
transxsph = 14;
transysph = 0;
transzsph = 5;
hcone = 24;
r1cone = 0;
r2cone = 15;
transxcone = -25;
transycone = 0;
transzcone = 20;
hcyl = 20;
rcyl = 3;
transxcyl = -24;
transycyl = 0;
transzcyl = 10;
rsphext = 3;
transzsphext = 10;
//base
translate(\[0, 0, transzbase\])cylinder(hbase, rbase, rbase, $fn = fn);
//tubeint
difference(){
cylinder(htubeint, rtubeint, rtubeint, $fn = fn);
union(){
translate(\[0, 0, transzvidetubeint\]) cylinder(hvidetubeint, rvidetubeint, rvidetubeint, $fn = fn);
translate(\[transxsph, transysph, transzsph\]) sphere(rsphere, $fn = fn);
}
}
//tubeext
difference(){
cylinder(htubeext, rtubeext, rtubeext, $fn = fn);
union(){
translate(\[0, 0, transzvidetubeext\]) cylinder(hvidetubeext, rvidetubeext, rvidetubeext, $fn = fn);
translate(\[transxcone, transycone, transzcone\])cylinder(hcone, r1cone, r2cone, $fn = fn);
translate(\[transxcyl, transycyl, transzcyl\]) cylinder(hcyl, rcyl, rcyl);
translate(\[transxcyl, 0, transzsphext\]) sphere(rsphext, $fn = fn);
}
}
Journal de bord - Avancée du projet à chaque étape, difficultés rencontrées, modifications et adaptations
##### 10/02/2023
On commence Ă transfĂ©rer le projet de l'Arduino Uno vers la nano mais on se rend vite compte qu'on n'a pas la bonne Arduino nano, il nous faut la 33ioT. Fabrice la commande pour la semaine suivante. ça nous bloque beaucoup parce qu'on ne peut pas commencer l'application non plus mais on est Ă peu prĂšs certain.e.s que tout fonctionne en-dehors de cela donc la session de la semaine suivante devrait ĂȘtre assez efficace.
##### 17/02/2023
IsmaĂ«l a rĂ©ussi Ă souder l'Arduino 33IOT et tout fonctionne. Seul problĂšme : les capteurs ne dĂ©tectent pas la prĂ©sence d'eau. On essaie de serrer + les vis, sinon il faudra peut-ĂȘtre changer de capteur ou trouver une autre solution.
En attendant on doit modéliser la piÚce manquante pour que l'hélice soit plus solide et voir si on a une tige de longueur suffisante pour passer sous le niveau du capteur bas.
On a rĂ©glĂ© le problĂšme en changeant les capteurs. Ils sont un peu moins rĂ©actifs mais ça ne gĂȘne pas le fonctionnement global donc on les garde.
On a modélisé la piÚce aux bonnes dimensions, mais on n'a pas de tige assez longue pour les nouveaux tubes du laboratoire. Pierre Théry va en commander à nouveau ou alors on peut en fabriquer une en tiges de métal mais on pense que ça ne sera pas assez rigide.
*Photo du systĂšme total fonctionnel.*
Léger problÚme d'étanchéité au bas du tube mais ça devrait se résoudre avec les tubes plus grands.
On a donc pu commencer à fouiller un peu pour créer l'application de contrÎle à distance. On a établi les fonctionnalités nécessaires avec Fabrice :
\- bouton démarrer le processus total
\- bouton allumer et Ă©teindre la pompe
\- bouton allumer et Ă©teindre le moteur agitateur
\- bouton Ă©teindre tout le systĂšme
il faut Ă©galement refaire la soudure de la Arduino nano 33ioT
##### 24/03/2023
AprÚs une série de tests par Téa, résultats assez étranges, globalement la filtration est moins rapide avec agitation moteur. On a rentré les résultats sur excel pour les analyser plus nettement :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-03/image-1680274558858.png)
Les temps les plus longs sont atteints lorsque le tube est agité par un moteur. Cela nous pose vraiment problÚme car le projet serait à moitié inefficace. On établit les sources d'erreurs potentielles :
\- la position dans la cuve pourrait influer car il y a 3 sources d'ultrasons pour 4 emplacements
\- le sens de rotation de l'hélice du moteur
On lance donc l'impression d'un bouchon avec emplacement moteur supplémentaire pour pouvoir faire plusieurs essais en parallÚle et plus facilement identifier le problÚme.
##### 31/03/2023
ProblÚme avec les impressions de la semaine passée, on n'avait pas pris en compte la dilatation lors de l'impression donc le moteur ne rentre pas dans l'emplacement prévu.
On recommence l'impression aux bonnes dimensions
Entre temps, Téa a refait des tests avec une membrane plus petite et une nouvelle cuve. Cette fois-ci l'agitation moteur permet bien un filtrage nettement plus rapide. Cela rend donc caduque le besoin d'un nouveau bouchon avec emplacement moteur. Voilà les graphiques obtenus avec les données de Téa :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/image-1683812151493.png)
De plus, les lames au microscope sont beaucoup moins polluĂ©es de particules sans intĂ©rĂȘt.
Nous n'avons pas eu le temps de rĂ©itĂ©rer suffisamment l'expĂ©rience et s'assurer que le rĂ©sultat serait identique Ă chaque rĂ©pĂ©tition. Cela peut ĂȘtre un bon axe de perfectionnement du systĂšme.
##### 14/04/2023
Nouvel objectif : rendre tout le systĂšme pilotable Ă distance grĂące au Arduino ioT Cloud
On transfÚre le code déjà créé pour la carte Arduino et on l'adapte aux exigences du cloud. Beaucoup de problÚmes de compilations, utilisation de Chat GPt4 pour les résoudre.
Il reste quelques problÚmes, on espÚre les résoudre avant l'oral : le code compile mais les moteurs ne s'activent pas lors de l'activation des widgets sur l'application arduino
Codes Openscad
N.B : ajuster les dimensions pour prendre en compte la modification Ă l'impression
hélice agitation moteur
```C++
$fn=100;
nbPales=6;
rAxeRot=1.5;
rIntTub=32/2;
rTube=18;
//color("red")
//render()
translate([0,0,1]) {
difference() {
cylinder (h = 2, r=rIntTub, center=true);
cylinder (h = 3, r=rIntTub-1, center=true);
}
}
difference() {
union (){
linear_extrude(height = 10, twist = 10, slices = 60) {
//circle(r=5);
for(i = [0 : 1 : nbPales]) {
rotate(a = i*360/nbPales) {
square(size = [rIntTub, 1]);
}
}
}
cylinder (h = 15, r=4, center = false);
}
translate([0,0,7.5]){
linear_extrude(height = 15, twist = 0, slices = 60){
translate ([0,0,3.5]) {
square(size = [5, 2],center=true);//rectangle 1
rotate (a=90){
square(size = [5, 2],center=true);
}
//cylinder (h = 30, r=rAxeRot);
}}}}
/*
translate ([0,0,-1]) {
cylinder (h = 30, r=rAxeRot);
}
*/
```
tige complĂšte
```C++
$fn=100;
nbPales=6;
rAxeRot=1.5;
rIntTub=32/2;
rTube=18;
//color("red")
//render()
translate([0,0,1]) {
difference() {
cylinder (h = 2, r=rIntTub, center=true);
cylinder (h = 3, r=rIntTub-1, center=true);
}
}
difference() {
union (){
linear_extrude(height = 10, twist = -10, slices = 60) {
//circle(r=5);
for(i = [0 : 1 : nbPales]) {
rotate(a = i*360/nbPales) {
square(size = [rIntTub, 1]);
}
}
}
cylinder (h = 147, r=3, center = false);
}
translate([0,0,140]){
cylinder (h = 30, r=0.5);
/*translate([0,0,7.5]){
linear_extrude(height = 15, twist = 0, slices = 60){
translate ([0,0,3.5]) {
square(size = [3.8, 1],center=true);//rectangle 1
rotate (a=90){
square(size = [3.8, 1],center=true);*/
}}
//vincent mouchi claire lix
//NB : le trou pour connexion moteur Ă©tait un peu trop faible, Ă agrandir
```
bouchon avec pas de vis et insert moteur
```C++
$fn=100;
hInt=20;
l=80;
diam=42.3;
/*
color("red")
translate ([-diam/2,-0.5,-hInt/2]) {
cube([diam,1,20], center=false);
}
color("green")
render()
translate ([-l/2,-0.5,5]) {
cube([l,1,4], center=false);
}
color("blue")
render()
difference () {
difference () {
cylinder (d=60, h=10);
cylinder (d=45, h=10);
}
translate ([-l/2,3,-l/2]) {cube([l,l,l], center=false);}
translate ([-l/2,-l-3,-l/2]) {cube([l,l,l], center=false);}
}
*/
translate ([0,0,-1]) {
difference () {
cylinder (d=50, h=3);
translate ([0,0,-0.5]) {cylinder (d=3, h=5);}
}
}
SVL42Cap ();
extend_mot();
difference(){
cylinder(d=16,h=2,center=true);
cylinder(d=3,h=2,center=true);}
module extend_mot (){//extension pour insertion moteur
difference (){
translate([0,0,-14])cylinder (d=50,h=14);
translate([0,0,-14])cylinder(d=21,h=10);
translate([0,0,-4]) cylinder(d=16,h=4);
}
}
/*difference () { // Pour observer une coupe
SVL42Cap ();
union () {
translate ([-l/2,5,-l/2]) {cube([l,l,l], center=false);}
translate ([-l/2,-l-5,-l/2]) {cube([l,l,l], center=false);}
}
}*/
module SVL42Cap () {
difference () {
cylinder (d=50, h=hInt);
moduleInt ();
}
difference () { // sommet du capuchon
color("red")
render()
union () {
cylinder (d=50, h=1.5);
difference () {
cylinder (d=50, h=1.5);
cylinder (d=3, h=2);
}
}
//translate ([-15,2,-5]) {cylinder (d=1, h=10);}
//translate ([-15,0,-5]) {cylinder (d=1, h=10);}
//translate ([-15,-2,-5]) {cylinder (d=1, h=10);}
}
}
module moduleInt () {
translate ([0,0,hInt]) {
difference () {
cylinder (d=45, h=3, center=true);
cylinder (d=37, h=4, center=true);
}
}
metric_thread (diameter=diam+4, pitch=4, length=hInt, internal=true, thread_size=2, groove=true, angle=10, leadin=0);
translate ([0,0,-0.5]) { cylinder (d=diam, h=hInt+1); }
}
/*module extension_moteur (){
difference (){
cylinder (d=50,h=10, center=true);
cylinder(d=21,h=10, center=true);
}
difference(){
cylinder(d=50,h=4, center=true);
cylinder(d=16,h=4, center = true);}
}*/
/*
metric_thread (diameter=8, pitch=1, length=4, internal=true);
diameter - outside diameter of threads in mm. Default: 8.
pitch - thread axial "travel" per turn in mm. Default: 1.
length - overall axial length of thread in mm. Default: 1.
internal - true = clearances for internal thread (e.g., a nut).
false = clearances for external thread (e.g., a bolt).
(Internal threads should be "cut out" from a solid using
difference ()).
n_starts - Number of thread starts (e.g., DNA, a "double helix," has
n_starts=2). See wikipedia Screw_thread.
thread_size - (non-standard) axial width of a single thread "V" - independent
of pitch. Default: same as pitch.
groove - (non-standard) subtract inverted "V" from cylinder (rather than
add protruding "V" to cylinder).
square - Square threads (per
https://en.wikipedia.org/wiki/Square_thread_form).
rectangle - (non-standard) "Rectangular" thread - ratio depth/(axial) width
Default: 1 (square).
angle - (non-standard) angle (deg) of thread side from perpendicular to
axis (default = standard = 30 degrees).
taper - diameter change per length (National Pipe Thread/ANSI B1.20.1
is 1" diameter per 16" length). Taper decreases from 'diameter'
as z increases.
leadin - 0 (default): no chamfer; 1: chamfer (45 degree) at max-z end;
2: chamfer at both ends, 3: chamfer at z=0 end.
leadfac - scale of leadin chamfer (default: 1.0 = 1/2 thread).
*/
/*
* ISO-standard metric threads, following this specification:
* http://en.wikipedia.org/wiki/ISO_metric_screw_thread
*
* Copyright 2017 Dan Kirshner - dan_kirshner@yahoo.com
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* See .
*
* Version 2.3. 2017-08-31 Default for leadin: 0 (best for internal threads).
* Version 2.2. 2017-01-01 Correction for angle; leadfac option. (Thanks to
* Andrew Allen .)
* Version 2.1. 2016-12-04 Chamfer bottom end (low-z); leadin option.
* Version 2.0. 2016-11-05 Backwards compatibility (earlier OpenSCAD) fixes.
* Version 1.9. 2016-07-03 Option: tapered.
* Version 1.8. 2016-01-08 Option: (non-standard) angle.
* Version 1.7. 2015-11-28 Larger x-increment - for small-diameters.
* Version 1.6. 2015-09-01 Options: square threads, rectangular threads.
* Version 1.5. 2015-06-12 Options: thread_size, groove.
* Version 1.4. 2014-10-17 Use "faces" instead of "triangles" for polyhedron
* Version 1.3. 2013-12-01 Correct loop over turns -- don't have early cut-off
* Version 1.2. 2012-09-09 Use discrete polyhedra rather than linear_extrude ()
* Version 1.1. 2012-09-07 Corrected to right-hand threads!
*/
// Examples.
//
// Standard M8 x 1.
// metric_thread (diameter=8, pitch=1, length=4);
// Square thread.
// metric_thread (diameter=8, pitch=1, length=4, square=true);
// Non-standard: long pitch, same thread size.
//metric_thread (diameter=8, pitch=4, length=4, thread_size=1, groove=true);
// Non-standard: 20 mm diameter, long pitch, square "trough" width 3 mm,
// depth 1 mm.
//metric_thread (diameter=20, pitch=8, length=16, square=true, thread_size=6,
// groove=true, rectangle=0.333);
// English: 1/4 x 20.
//english_thread (diameter=1/4, threads_per_inch=20, length=1);
// Tapered. Example -- pipe size 3/4" -- per:
// http://www.engineeringtoolbox.com/npt-national-pipe-taper-threads-d_750.html
// english_thread (diameter=1.05, threads_per_inch=14, length=3/4, taper=1/16);
// Thread for mounting on Rohloff hub.
//difference () {
// cylinder (r=20, h=10, $fn=100);
//
// metric_thread (diameter=34, pitch=1, length=10, internal=true, n_starts=6);
//}
// ----------------------------------------------------------------------------
function segments (diameter) = min (50, ceil (diameter*6));
// ----------------------------------------------------------------------------
// diameter - outside diameter of threads in mm. Default: 8.
// pitch - thread axial "travel" per turn in mm. Default: 1.
// length - overall axial length of thread in mm. Default: 1.
// internal - true = clearances for internal thread (e.g., a nut).
// false = clearances for external thread (e.g., a bolt).
// (Internal threads should be "cut out" from a solid using
// difference ()).
// n_starts - Number of thread starts (e.g., DNA, a "double helix," has
// n_starts=2). See wikipedia Screw_thread.
// thread_size - (non-standard) axial width of a single thread "V" - independent
// of pitch. Default: same as pitch.
// groove - (non-standard) subtract inverted "V" from cylinder (rather than
// add protruding "V" to cylinder).
// square - Square threads (per
// https://en.wikipedia.org/wiki/Square_thread_form).
// rectangle - (non-standard) "Rectangular" thread - ratio depth/(axial) width
// Default: 1 (square).
// angle - (non-standard) angle (deg) of thread side from perpendicular to
// axis (default = standard = 30 degrees).
// taper - diameter change per length (National Pipe Thread/ANSI B1.20.1
// is 1" diameter per 16" length). Taper decreases from 'diameter'
// as z increases.
// leadin - 0 (default): no chamfer; 1: chamfer (45 degree) at max-z end;
// 2: chamfer at both ends, 3: chamfer at z=0 end.
// leadfac - scale of leadin chamfer (default: 1.0 = 1/2 thread).
module metric_thread (diameter=8, pitch=1, length=1, internal=false, n_starts=1,
thread_size=-1, groove=false, square=false, rectangle=0,
angle=30, taper=0, leadin=0, leadfac=1.0)
{
// thread_size: size of thread "V" different than travel per turn (pitch).
// Default: same as pitch.
local_thread_size = thread_size == -1 ? pitch : thread_size;
local_rectangle = rectangle ? rectangle : 1;
n_segments = segments (diameter);
h = (square || rectangle) ? local_thread_size*local_rectangle/2 : local_thread_size / (2 * tan(angle));
h_fac1 = (square || rectangle) ? 0.90 : 0.625;
// External thread includes additional relief.
h_fac2 = (square || rectangle) ? 0.95 : 5.3/8;
tapered_diameter = diameter - length*taper;
difference () {
union () {
if (! groove) {
metric_thread_turns (diameter, pitch, length, internal, n_starts,
local_thread_size, groove, square, rectangle, angle,
taper);
}
difference () {
// Solid center, including Dmin truncation.
if (groove) {
cylinder (r1=diameter/2, r2=tapered_diameter/2,
h=length, $fn=n_segments);
} else if (internal) {
cylinder (r1=diameter/2 - h*h_fac1, r2=tapered_diameter/2 - h*h_fac1,
h=length, $fn=n_segments);
} else {
// External thread.
cylinder (r1=diameter/2 - h*h_fac2, r2=tapered_diameter/2 - h*h_fac2,
h=length, $fn=n_segments);
}
if (groove) {
metric_thread_turns (diameter, pitch, length, internal, n_starts,
local_thread_size, groove, square, rectangle,
angle, taper);
}
}
}
// chamfer z=0 end if leadin is 2 or 3
if (leadin == 2 || leadin == 3) {
difference () {
cylinder (r=diameter/2 + 1, h=h*h_fac1*leadfac, $fn=n_segments);
cylinder (r2=diameter/2, r1=diameter/2 - h*h_fac1*leadfac, h=h*h_fac1*leadfac,
$fn=n_segments);
}
}
// chamfer z-max end if leadin is 1 or 2.
if (leadin == 1 || leadin == 2) {
translate ([0, 0, length + 0.05 - h*h_fac1*leadfac]) {
difference () {
cylinder (r=diameter/2 + 1, h=h*h_fac1*leadfac, $fn=n_segments);
cylinder (r1=tapered_diameter/2, r2=tapered_diameter/2 - h*h_fac1*leadfac, h=h*h_fac1*leadfac,
$fn=n_segments);
}
}
}
}
}
// ----------------------------------------------------------------------------
module metric_thread_turns (diameter, pitch, length, internal, n_starts,
thread_size, groove, square, rectangle, angle,
taper)
{
// Number of turns needed.
n_turns = floor (length/pitch);
intersection () {
// Start one below z = 0. Gives an extra turn at each end.
for (i=[-1*n_starts : n_turns+1]) {
translate ([0, 0, i*pitch]) {
metric_thread_turn (diameter, pitch, internal, n_starts,
thread_size, groove, square, rectangle, angle,
taper, i*pitch);
}
}
// Cut to length.
translate ([0, 0, length/2]) {
cube ([diameter*3, diameter*3, length], center=true);
}
}
}
// ----------------------------------------------------------------------------
module metric_thread_turn (diameter, pitch, internal, n_starts, thread_size,
groove, square, rectangle, angle, taper, z)
{
n_segments = segments (diameter);
fraction_circle = 1.0/n_segments;
for (i=[0 : n_segments-1]) {
rotate ([0, 0, i*360*fraction_circle]) {
translate ([0, 0, i*n_starts*pitch*fraction_circle]) {
//current_diameter = diameter - taper*(z + i*n_starts*pitch*fraction_circle);
thread_polyhedron ((diameter - taper*(z + i*n_starts*pitch*fraction_circle))/2,
pitch, internal, n_starts, thread_size, groove,
square, rectangle, angle);
}
}
}
}
// ----------------------------------------------------------------------------
module thread_polyhedron (radius, pitch, internal, n_starts, thread_size,
groove, square, rectangle, angle)
{
n_segments = segments (radius*2);
fraction_circle = 1.0/n_segments;
local_rectangle = rectangle ? rectangle : 1;
h = (square || rectangle) ? thread_size*local_rectangle/2 : thread_size / (2 * tan(angle));
outer_r = radius + (internal ? h/20 : 0); // Adds internal relief.
//echo (str ("outer_r: ", outer_r));
// A little extra on square thread -- make sure overlaps cylinder.
h_fac1 = (square || rectangle) ? 1.1 : 0.875;
inner_r = radius - h*h_fac1; // Does NOT do Dmin_truncation - do later with
// cylinder.
translate_y = groove ? outer_r + inner_r : 0;
reflect_x = groove ? 1 : 0;
// Make these just slightly bigger (keep in proportion) so polyhedra will
// overlap.
x_incr_outer = (! groove ? outer_r : inner_r) * fraction_circle * 2 * PI * 1.02;
x_incr_inner = (! groove ? inner_r : outer_r) * fraction_circle * 2 * PI * 1.02;
z_incr = n_starts * pitch * fraction_circle * 1.005;
/*
(angles x0 and x3 inner are actually 60 deg)
/\ (x2_inner, z2_inner) [2]
/ \
(x3_inner, z3_inner) / \
[3] \ \
|\ \ (x2_outer, z2_outer) [6]
| \ /
| \ /|
z |[7]\/ / (x1_outer, z1_outer) [5]
| | | /
| x | |/
| / | / (x0_outer, z0_outer) [4]
| / | / (behind: (x1_inner, z1_inner) [1]
|/ | /
y________| |/
(r) / (x0_inner, z0_inner) [0]
*/
x1_outer = outer_r * fraction_circle * 2 * PI;
z0_outer = (outer_r - inner_r) * tan(angle);
//echo (str ("z0_outer: ", z0_outer));
//polygon ([[inner_r, 0], [outer_r, z0_outer],
// [outer_r, 0.5*pitch], [inner_r, 0.5*pitch]]);
z1_outer = z0_outer + z_incr;
// Give internal square threads some clearance in the z direction, too.
bottom = internal ? 0.235 : 0.25;
top = internal ? 0.765 : 0.75;
translate ([0, translate_y, 0]) {
mirror ([reflect_x, 0, 0]) {
if (square || rectangle) {
// Rule for face ordering: look at polyhedron from outside: points must
// be in clockwise order.
polyhedron (
points = [
[-x_incr_inner/2, -inner_r, bottom*thread_size], // [0]
[x_incr_inner/2, -inner_r, bottom*thread_size + z_incr], // [1]
[x_incr_inner/2, -inner_r, top*thread_size + z_incr], // [2]
[-x_incr_inner/2, -inner_r, top*thread_size], // [3]
[-x_incr_outer/2, -outer_r, bottom*thread_size], // [4]
[x_incr_outer/2, -outer_r, bottom*thread_size + z_incr], // [5]
[x_incr_outer/2, -outer_r, top*thread_size + z_incr], // [6]
[-x_incr_outer/2, -outer_r, top*thread_size] // [7]
],
faces = [
[0, 3, 7, 4], // This-side trapezoid
[1, 5, 6, 2], // Back-side trapezoid
[0, 1, 2, 3], // Inner rectangle
[4, 7, 6, 5], // Outer rectangle
// These are not planar, so do with separate triangles.
[7, 2, 6], // Upper rectangle, bottom
[7, 3, 2], // Upper rectangle, top
[0, 5, 1], // Lower rectangle, bottom
[0, 4, 5] // Lower rectangle, top
]
);
} else {
// Rule for face ordering: look at polyhedron from outside: points must
// be in clockwise order.
polyhedron (
points = [
[-x_incr_inner/2, -inner_r, 0], // [0]
[x_incr_inner/2, -inner_r, z_incr], // [1]
[x_incr_inner/2, -inner_r, thread_size + z_incr], // [2]
[-x_incr_inner/2, -inner_r, thread_size], // [3]
[-x_incr_outer/2, -outer_r, z0_outer], // [4]
[x_incr_outer/2, -outer_r, z0_outer + z_incr], // [5]
[x_incr_outer/2, -outer_r, thread_size - z0_outer + z_incr], // [6]
[-x_incr_outer/2, -outer_r, thread_size - z0_outer] // [7]
],
faces = [
[0, 3, 7, 4], // This-side trapezoid
[1, 5, 6, 2], // Back-side trapezoid
[0, 1, 2, 3], // Inner rectangle
[4, 7, 6, 5], // Outer rectangle
// These are not planar, so do with separate triangles.
[7, 2, 6], // Upper rectangle, bottom
[7, 3, 2], // Upper rectangle, top
[0, 5, 1], // Lower rectangle, bottom
[0, 4, 5] // Lower rectangle, top
]
);
}
}
}
}
```
Code Arduino nano par Ismaël
```C
#include
const unsigned long equivalence_ms_s=1000; // constante pour la convertion des ms en s
unsigned long heure_start_ms, heure_start_sec; // variables pour stocker l'heure du début en ms et s
unsigned long heure_delay_ms, heure_delay_sec; // variables pour stocker l'heure du retard en ms et s
void setup() {
Serial.begin(9600); // initialisation de la communication série à 9600 bites par s
//Establishing the communication with the motor shield
if (controller.begin())
{
Serial.print("MKR Motor Shield connected, firmware version ");
Serial.println(controller.getFWVersion());
}
else
{
Serial.println("Couldn't connect! Is the red led blinking? You may need to update the firmware with FWUpdater sketch");
while (1);
}
// Reboot the motor controller; brings every value back to default
Serial.println("reboot");
controller.reboot();
delay(500);
M1.setDuty(0);
M2.setDuty(0);
}
int remplissage=1; // variable "remplissage" qui vaut 1 par défaut
int chrono = 0; // variable "chrono" qui vaut 0 par défaut
void loop() {
int sensorValue0 = analogRead(A7); // lit la valeur analogique reçue en A0, envoyée par le capteur BAS
int sensorValue1 = analogRead(A2); // lit la valeur analogique reçue en A2, envoyée par le capteur HAUT
//Serial.println(sensorValue1);
Serial.println(sensorValue0);
float voltage0 = sensorValue0 * (5.0 / 1023.0); // conversion de la valeur analogique (de 0 Ă 1023) en voltage (de 0 Ă 5V) - capteur BAS
float voltage1 = sensorValue1 * (5.0 / 1023.0); // conversion de la valeur analogique (de 0 Ă 1023) en voltage (de 0 Ă 5V) - capteur HAUT
//Serial.println(voltage0);
//Serial.println(voltage1); |||||||||
if (remplissage == 1) { // si le niveau d'eau est sous le capteur du HAUT, alors :
if ((voltage0< 2.5) & (voltage1 < 2.5)) { // si le capteur BAS ne détecte pas l'eau, alors :
M1.setDuty(20); //On fait tourner le moteur Ă 20%
M2.setDuty(100); // On fait tourner la pompe Ă fond
remplissage = 1; // on reste dans cette boucle
}
if ((voltage0> 2.5) & (voltage1 < 2.5)) { // si le capteur BAS ne détecte pas l'eau, alors :
M1.setDuty(20); // On fait tourner le moteur Ă 20%
M2.setDuty(100); // On fait tourner la pompe Ă fond
}
if ((voltage1 > 2.5)&(voltage0>2.5)){ // si le capteur HAUT détecte l'eau, alors :
M1.setDuty(0); // On coupe le moteur
M2.setDuty(0); // On coupe la pompe
remplissage=0; // on entre dans la boucle suivante
heure_start_ms = millis(); // dÚs que le capteur HAUT détecte l'eau, lecture de l'heure du début en ms
heure_start_sec = (heure_start_ms/equivalence_ms_s);
chrono = 0; // conversion des ms en s
}
}
if (remplissage == 0) { // si le niveau d'eau est au dessus le capteur HAUT, alors :
if (voltage0 > 2.5) { // si le niveau d'eau est au dessus le capteur BAS, alors
if (chrono <= 5) { // si le chrono est < 5 s, alors :
M1.setDuty(20); // "pas de courant" en sortie 2 : le circuit est fermé dans la carte relais, le moteur fonctionne
M2.setDuty(0);
heure_delay_ms = millis(); // lecture du retard en ms
heure_delay_sec = (heure_delay_ms/equivalence_ms_s); // conversion des ms en s
chrono = heure_delay_sec - heure_start_sec; // calcul du chrono = (heure du début - heure du retard)
remplissage = 0;
}
if ((chrono <= 60) & (chrono > 5)) {// si le chrono est > 5 s, alors :
M1.setDuty(0); // On eteint le moteur
M2.setDuty(0); // On eteint la pompe
heure_delay_ms = millis(); // lecture de l'heure du retard en ms
heure_delay_sec = (heure_delay_ms/equivalence_ms_s); // conversion des ms en s
chrono = heure_delay_sec - heure_start_sec; // calcul du chrono = (heure du début - heure du retard)
remplissage = 0;
}
if (chrono > 60) { // si le chrono > 10 s, alors :
chrono = 0; // le chrono est remis Ă 0
heure_start_ms = millis(); // l'heure du début est remis à jour en ms
heure_start_sec = (heure_start_ms/equivalence_ms_s); // conversion des ms en s
remplissage = 0;
}
}
if (voltage0 < 2.5) {
remplissage = 1;
}
}
//Serial.println(remplissage); ||||||||||||||||||
} // ferme void loop
```
Journal de bord
**27/01/2023**
Aujourd'hui, nous voyons avec le professeur ce qu'il souhaite pour le projet. Nous devons réaliser cinq sets d'entrainements et cinq sets de corrections. Pour cela , nous allons principalement utiliser l'impression 3D que ce soit avec de l'acide polyactique (PLA) ou de la résine. Les deux nécessitent des fichiers au format stl.
Nous sommes partis sur des modÚles de 6cmx6cm. Nous avons commencé par visualiser avec Vesta certains minéraux pour découvrir leur structure. Nous avons alors remarqué que nous pouvions faire les fichiers stl à partir de Vesta. Cependant, il n'était pas possible de faire les axes de symétries.
Dans un premier temps, nous allons recrĂ©er les mailles primitives Ă l'aide d'Openscad pour rĂ©aliser une base de donnĂ©es utilisable par les Ă©tudiants oĂč ils pourront modifier les paramĂštres de mailles Ă leur guise. Une fois la base de donnĂ©e constituĂ©e, nous pourrons ajouter les Ă©lĂ©ments de symĂ©tries sur les mailles. Nous partirons sur des gravures pour reprĂ©senter les Ă©lĂ©ments de symĂ©tries.
Pour la semaine prochaine, il serait bien que nous testions les impressions 3D et le flocage. C'est une technique qui nous permettrait de rajouter les éléments de symétries sur les polygones.
**03/02/2023**
Camille a rĂ©alisĂ© un code pour que les Ă©lĂšves de M. ChassĂ© puissent retrouver les systĂšmes cristallins. Ce code est censĂ© marcher pour tous les systĂšmes. C'est Ă dire qu'en rentrant les paramĂštres a, b, c, alpha, bĂȘta et gamma, le logiciel Openscad sera capable de recrĂ©er la maille voulue.
Pendant ce temps, Alexandre a imprimé les premiers modÚles en PLA et a codé le systÚme monoclinique avec ses éléments de symétries afin de savoir comment cela pourrait rendre (prise en main, poids, taille). Openscad a permis de fabriquer les fichiers stl mais il a fallu ensuite les rentrer dans IdeaMaker pour les rendre compatibles avec les imprimantes du Fablab, organiser le plateau, la qualité d'impression et éventuellement agrandir ou rétrécir les modÚles.
Les imprimantes PLA se situent dans l'espace prototypage.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/1ere-impression.jpeg)
PremiĂšre impression en PLA : deux systĂšmes monocliniques
**07/03/2023**
Nous avons lancĂ© les impressions des systĂšmes quadratiques, monocliniques et orthorhombiques avec des Ă©lĂ©ments de symĂ©tries. Il Ă©tait compliquĂ©, juste avec Openscad, de bien ajuster les tailles des axes ou des miroirs par rapport Ă celle de la maille. Cette impression Ă©tait un test pour savoir Ă quel point les Ă©lĂ©ments doivent ĂȘtre gros.
**08/02/2023**
Lorsque les modÚles à imprimer deviennent complexes, il est parfois nécessaire d'utiliser des supports pour stabiliser la structure et donner un sol sur lequel l'imprimante peut construire sa réalisation. Les impressions de la semaine derniÚre ont raté vraisemblablement à cause de la mauvaise gestion des supports. Soit ils n'y en avaient pas assez, soit ils étaient trop fins.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/ratage-dimpression-du-08-02.jpeg)
[Echec de l'impression de quatre modĂšles : deux quadratiques et deux orthorhombiques](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/ratage-dimpression-du-08-02.jpeg)
Seuls les monocliniques ont Ă©tĂ© Ă©pargnĂ©s. Cependant les axes sont minuscules, ce qui les rend extrĂȘmement fragiles et les miroirs font brouillons. De plus, il y a une erreur dans le codage de ces monocliniques. En effet, ils n'ont pas Ă©tĂ© dĂ©finis Ă partir des paramĂštres a, b, c, alpha, bĂȘta et gamma mais Ă partir de coordonnĂ©es dont certaines erronĂ©es.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/deux-monocliniques-v1-axes.jpeg)
[PremiÚres impressions avec axes de symétries ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/deux-monocliniques-v1-axes.jpeg)
**10/02/2023**
Nous avons relancĂ© des impressions PLA des systĂšmes monoclinique (avec les bonnes dimensions cette fois-ci), quadratique et orthorhombique. Nous avons allongĂ© et grossi les axes. Sur les impressions ci-dessous, plusieurs choses peuvent ĂȘtre remarquĂ©es. DĂ©jĂ , le monoclinique est un test de reprĂ©sentation inversĂ©e. Au lieu de faire ressortir les axes, nous les avons creusĂ©s et au lieu de graver le miroir, nous l'avons fait ressortir. Cette visualisation ne sera pas gardĂ©e.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/monoclique-sym-inversededicace.jpeg)
Ensuite, pour les deux autres modÚles, la forme des axes varie. En effet, celle-ci est codifiée et correspond à la valeur de l'axe. S'il permet de faire 2 rotations, il sera ovale, un triangle, 4 un carré et 6 un hexagone. Enfin, il manque quelques plans miroirs sur le quadratique.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/quadratique-v1-vrai.jpeg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/quadratique-v1.jpeg)
**Rendez-vous et bilan de l'avancée du projet**
Nous nous sommes alors entretenus avec M. ChassĂ©. La taille de ces modĂšles lui convenait. En outre, nous pouvions voir sur le monoclinique les traces d'un marqueur pour tableau qu'il a effectuĂ©. Notre professeur souhaitait que ses Ă©tudiants puissent dessiner sur les futurs modĂšles d'entrainements puis effacer. Pour cette raison, les impressions finales d'entrainements seront blanches pour mieux voir l'encre. Par ailleurs, les premiĂšres impressions ont Ă©tĂ© conçues en exagĂ©rant les proportions de maniĂšre Ă ĂȘtre le plus explicite possible. Elles ne sont pas, pour cette raison, reprĂ©sentatives de la rĂ©alitĂ©. M. ChassĂ© nous a demandĂ© de caler les paramĂštres des modĂšles sur les dimensions de certains minĂ©raux existant pour Ă©viter les erreurs de reprĂ©sentation et de proportion. Il nous a prĂ©cisĂ© ensuite de faire attention Ă la longueur des axes. M. Labrousse a approuvĂ© cette idĂ©e en ajoutant que des axes longs seraient fragiles.
A présent, il existe deux versions des programmes Openscad pour les étudiants afin qu'ils puissent visualiser les modÚles en ligne.
Programme n°1 :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-04/image-1682614173389.png)
Programme n°2 :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/image-1683750192019-21-30.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/image-1683750211363-22-01.png)
Nous repartons donc aujourd'hui avec beaucoup d'objectifs :
- vérifier s'il est possible d'effacer le marqueur des impressions PLA comme résine,
- tester l'Ă©thanol pour savoir s'il endommage les impressions car ce solvant permet d'enlever les marqueurs,
- faire des impressions résines,
- essayer avec M. Théry la lisseuse, un instrument chauffant pour lisser nos productions,
- regarder si avec la découpeuse vinyle, coller des stickers afin d'écrire sur les modÚles est envisageable,
- voir si nous pouvons, à l'aide de la découpeuse à eau, recouvrir nos productions de plexiglas,
- terminer toutes les corrections. Actuellement, il nous manque les systÚmes rhomboédrique, cubique et hexagonale.
Par ailleurs, il est envisagé, sous réserve que nous terminions rapidement, de reproduire des mailles de minéraux existants, de coder les modÚles avec les motifs (atomes ou molécules) dedans.
**12/02/2023**
Les systĂšmes classiques sont tous terminĂ©s pour les modĂšles simples (voir SystĂšmes cristallins classiques) et une partie des modĂšles avec axes aussi. (voir SystĂšmes cristallins avec symĂ©tries). Nous avons testĂ© la lisseuse. Elle a dĂ©formĂ© notre modĂšle. A la place, M. ThĂ©ry nous a proposĂ© d'utiliser la dĂ©coupeuse vinyle pour coller un papier Velleda sur nos impressions en PLA afin d'avoir les formes parfaites. Cela nĂ©cessiterait l'utilisation du logiciel Inkscape pour avoir le chemin vectoriel. Il faut juste vĂ©rifier les dimensions du film pour savoir s'il est compatible avec la dĂ©coupeuse. Nous pourrions Ă©galement tester de lisser la surface avec du sable chauffĂ© puisque le fer chauffĂ© dĂ©forme notre structure. Enfin, plusieurs personnes nous ont conseillĂ©s de faire un trou universel dans les modĂšles puis de laisser les Ă©tudiants trouver quels axes correspondent Ă quelles cavitĂ©s. Mais nous n'avons pas gardĂ© cette proposition pour plusieurs raisons. D'abord, souvent les axes s'entrecroisent au centre de la maille. Pour Ă©viter qu'ils ne se gĂȘnent, il aurait fallu les raccourcir de façon prĂ©cise. Mais le principal problĂšme rencontrĂ© concerne le maintien des axes au sein de la structure. Nous aurions dĂ» crĂ©er un systĂšme de clefs et de serrures pour Ă©viter que les axes ne tombent en manipulant le modĂšle.
**17/02/2023**
Lorsqu'un minĂ©ral est trouvĂ© dans la rĂ©alitĂ©, sa forme ne correspond pas forcĂ©ment Ă sa maille primitive. Il a pu ĂȘtre dĂ©coupĂ© selon des plans bien prĂ©cis. On parle alors de troncature. Ci-dessous, il s'agit de la rĂ©alisation de troncatures pour le systĂšme cubique.
**Essai de troncature du systÚme cubique (cubo-octaédre) :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/image-1676714450773-00-43.png)
**Essai de troncature du systÚme cubique avec symétries (cubo-octaédre):**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/image-1676714788778-06-23.png)
Au sein de la facultĂ©, les impressions rĂ©sine dĂ©pendent du Fablab de biologie/chimie. Il a fallu se rendre au Fablab biologie Ă l'atrium pour demander des informations sur l'imprimante rĂ©sine mais il Ă©tait fermĂ©. Camille est allĂ©e faire un tour au Fablab chimie pour savoir s'il Ă©tait possible de lancer une impression rĂ©sine du systĂšme cubique avec axes de symĂ©tries. Cependant, le responsable du Fablab de chimie, a expliquĂ© que les impressions doivent ĂȘtre lancĂ©es le jeudi. La rĂ©sine est un fluide qui se polymĂ©rise sous l'effet des UV. Il faut stopper manuellement la rĂ©action pour Ă©viter des dĂ©gĂąts sur les produits. Si les impressions Ă©taient lancĂ©es les vendredis soirs, au retour du week-end, elles seraient abimĂ©es ainsi que le matĂ©riel.
Camille enverra un mail ce week-end à Simon Lanis afin de convenir d'une date. Egalement, il serait bien d'écrire sur des échantillons de résine afin de savoir si nous pouvons effacer le marqueur. Comme les BIC Velleda sont les plus compliqués à enlever, nous allons faire nos essais de dessins avec.
L'impression du systĂšme cubique en haute rĂ©solution avec une coque trĂšs fine et un remplissage de 15% a pu ĂȘtre lancĂ©e. Il s'agit de la premiĂšre impression haute rĂ©solution effectuĂ©e. Si au toucher elles sont plus lisses et visuellement plus jolies, la durĂ©e d'impression est beaucoup plus longue. Nous pourrons ainsi disposer d'un aperçu du rendu "final" que pourrait donner les systĂšmes. En principe, l'impression devrait ĂȘtre terminĂ©e ce week-end.
En parallÚle, nous nous sommes rendu compte que les programmes servant à recréer les mailles ne fonctionnaient pas pour le systÚme rhomboédrique. En effet, en comparant la taille des diagonales des faces, elles étaient toutes différentes. Or, le rhomboÚdre est composé de 6 losanges identiques. Il fallait donc recoder ce systÚme complÚtement puis ajouter les axes dessus. Cela signifiait également un disfonctionnement des programmes les rendant inaptes à l'enseignement. Il s'agissait du seul systÚme nous faisant défaut.
Dans un second temps, il nous faudra rĂ©soudre les problĂšmes de surface des piĂšces, elles doivent ĂȘtre les plus lisses possibles pour Ă©viter l'absorption de l'encre au sein des porositĂ©s. La rĂ©sine pourrait ĂȘtre une solution. En effet, si le film Velleda ne tient pas ou bien s'il est abĂźmĂ© par les Ă©tudiants, le projet ne sera pas viable sur le long terme.
Les axes de symĂ©tries sont dĂ©finitivement trop fragiles. Au moindre choc, chute, transport dans une poche, ils se cassent. Il faut trouver un meilleur rapport entre longueur/Ă©paisseur des axes pour les prĂ©server au maximum. Des axes plus petits mais plus larges semblent ĂȘtre adaptĂ©s.
Dans un troisiÚme temps, nous pourrions créer deux boites avec la découpeuse laser ou un autre appareil pour ranger proprement tous les systÚmes.
**24/02/2023 **
L'impression du cube a partiellement fonctionné. Les axes situés sur la face inférieure n'ont pas été correctement imprimés. En outre, elle souffre aussi d'un défaut puisqu'elle n'est pas lisse. Cela est dû au socle trop épais, difficile à retirer. En temps normal, les structures supports partent relativement facilement. Cependant, ici, il a fallu utiliser un cutter à ultrasons pour les couper puis limer le surplus de matiÚre de la face postérieure. Pour les prochains essais, il serait bien d'utiliser des supports plus conséquents et plus larges que la face du cube. Le reste du modÚle est parfaitement imprimé, la surface est beaucoup mieux aboutie que les autres modÚles et les axes plus petits devraient mieux résister.
[Résultat de l'impression avec la meilleure résolution : ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/image-1677322584654.jpeg)
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/image-1677322058742.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/image-1677322457802.jpeg)
[Photos de la face ratée avant et aprÚs limage ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-04/image-1682695057363.png):
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-04/image-1682695057363.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-04/image-1682695168084.jpg)
[Cutter Ă Ultrasons](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/image-1677323173717.jpg) :
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/image-1677323173717.jpg)
Réalisation d'essais de traces aux marqueurs sur des échantillons en résine :
Lorsque nous recevons pour la premiĂšre fois les Ă©chantillons en rĂ©sine, il nous est apparu que certains marqueurs pouvaient ĂȘtre effacĂ©s. Les marqueurs bleus et verts semblent ĂȘtre adaptĂ©s Ă notre projet puisqu'effaçables mĂȘme aprĂšs une heure d'attente. Ainsi, l'utilisation de rĂ©sine translucide semble ĂȘtre une des solutions rĂ©pondant aux critĂšres de M.ChassĂ©.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/image-1677323894846.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/image-1677323894869.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/image-1677323894885.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/image-1677323894900.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/image-1677323894922.jpg)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-02/image-1677324550017-28-14.jpg)
Pour la semaine prochaine, nous devons continuer à chercher les axes et plans miroirs du systÚme rhomboédrique. En effet, il n'est toujours pas codé de façon correcte.
Par ailleurs, la boĂźte de fin de projet pourrait ĂȘtre construite Ă la dĂ©coupeuse laser. Des crans sur les cĂŽtĂ©s de celle-ci serviraient Ă l'assemblage de chacune de ses faces. Enfin, l'intĂ©rieur comporterait de la mousse afin de prĂ©server les impressions.
**10/03/2023**
Le code du systĂšme rhomboĂ©drique a enfin Ă©tĂ© trouvĂ©. Depuis plusieurs semaines, nous Ă©tions bloquĂ©s sur son automatisation au sein d'Openscad. Pour des valeurs de paramĂštres conformes Ă la dĂ©finition du rhomboĂšdre (a=b=c, alpha=bĂȘta=gamma), les losanges obtenus diffĂ©raient les uns des autres. Nous nous en sommes rendu compte grĂące aux axes. Il Ă©tait impossible de les baser sur nos paramĂštres. Il fallait tout le temps tĂątonner au cas par cas lĂ oĂč pour les autres systĂšmes tout est automatique. Cela nous a pris 3 semaines pour comprendre comment dĂ©finir les longueurs de ce polyĂšdre. Par ailleurs, comme ce systĂšme ne marchait pas dans les codes d'amusement des futurs Ă©tudiants Ă cause de la complexitĂ© des coordonnĂ©es, il est plus que probable que les codes ne marchent pas non plus pour le systĂšme triclinique. Il dispose de trop de translations interdĂ©pendantes les unes des autres pour ĂȘtre aussi simple Ă coder. Si nous disposons d'un peu de temps Ă la fin, il pourrait ĂȘtre intĂ©ressant de trouver comment le crĂ©er dans Openscad.
AprÚs avoir testé plein de variantes différentes, c'est finalement via la résolution d'un systÚme à deux inconnus que les translations ont été trouvées. C'est en effet le passage de la structure 2D en 3D qui posait problÚme. D'une part le triangle rectangle entre la translation en x, la longueur a (hypoténuse) et la hauteur mais également via les coordonnées du vecteur BE, et BD dont on a comparé les normes.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-04/image-1682697127775.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-03/image-1679059731159.JPEG)[Schémas de la solution](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-04/image-1682697127775.png)
```C++
//variable
a=6.36;
alpha=46.6;
//définition des translations
ralpha=alpha*3.14/180;
x=a*cos(alpha/2);
y=a*sin(alpha/2);
x1=(y)^2;
x2=(x)^2;
x3=2*x;
tx=(a^2-3*x1+x2)/x3;
tz=sqrt(a^2-tx^2);
//polyĂšdre
A=[0 ,0 ,0 ];
B=[x ,y ,0 ];
C=[2*x ,0 ,0 ];
D=[x ,-y ,0 ];
E=[tx ,0 ,tz ];
F=[tx+x ,y ,tz ];
G=[2*x+tx,0 , tz];
H=[tx+x ,-y , tz];
points=[
A,
B,
C,
D,
E,
F,
G,
H];
face=[[0,1,2,3],//sol
[4,5,1,0],//au dessusi
[7,6,5,4],//derriĂšre
[5,6,2,1],//droite
[6,7,3,2],//gauche
[7,4,0,3]];//devant
//vérification
polyhedron(points,face);
v1=B-E;// B et E
v2=H-F;// F et H
v3=A-F;
v4=A-C;
nv1=norm(v1);
nv2=norm(v2);
nv3=norm(v3);
nv4=norm(v4);
echo(nv1,"norme de v1");
echo(nv2,"norme de v2");
echo(nv3,"norme de v3");
echo(nv4,"norme de v4");
echo (tx,tz);
```
Code pour le rhomboĂšdre
Il est Ă noter que ce code marche Ă©galement pour le cube si les angles sont Ă©gaux Ă 90°, c'est pour cela que dans la dĂ©finition du rhomboĂšdre, les angles doivent ĂȘtre diffĂ©rents de 90°.
**17/03/2023 **
Nous avons continué la pose des axes de symétries sur le rhomboÚdre. En parallÚle, trois nouveaux modÚles en PLA ont été imprimés afin de les recouvrir de papier film Velleda. La commande que nous avions passé, est arrivée la semaine derniÚre. Enfin, le cube a été projeté afin de tester sa résistance. Certains éléments de symétries ont été cassés. Leur durée de vie est donc le principal souci pour les modÚles de corrections.
**22/03/2023 :**
Une impression résine a été lancée pour les systÚmes suivants :
\- cubique classique
\- quadratique classique
\- orthorhombique classique
\- monocline classique
\- triclinique classique
\- hexagonal classique
\- cubique corrigé
\- quadratique corrigé
\- orthorhombique corrigé
Il Ă©tait initialement prĂ©vu d'imprimer le rhomboĂ©drique classique. Cependant, le fichier slt ne se chargeait pas sur le logiciel de visualisation Chitubox. L'utilisation de l'imprimante en rĂ©sine est plus technique et plus coĂ»teuse que celles utilisant le PLA. De plus, le bac doit ĂȘtre rempli de façon prĂ©cise avant l'impression pour Ă©viter d'ĂȘtre en manque de rĂ©sine pendant la fabrication des modĂšles. Ici il fallait 62ml.
Les systÚmes ont été fabriqués simultanément à l'aide d'une seule imprimante en résine grise. Ils font environ 2cm de long. C'est plus petit que les autres impressions mais cela a permis de tous les avoir rapidement. Nous pourrions les avoir en blancs, noirs ou transparents. Ce serait bien d'essayer ces couleurs afin de les comparer.
**24/03/2023**:
L'impression des modÚles en résine a duré 2 heures. Elle n'a pas fonctionné pour les polygones dans la partie gauche du récipient contenant la résine. Néanmoins, la définition des objets est bien plus fine qu'avec l'impression à filament.
Ainsi les systÚmes imprimés à ce jour sont :
\- systĂšme cubique classique
\- systÚme cubique corrigé
\- systĂšme monoclinique classique
\- systÚme orthorhombique corrigé
\- systĂšme hexagonal classique
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-03/image-1679653957012-32-33.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-03/image-1679653696119-26-42.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-03/image-1679653696267-26-30.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-03/image-1679653696150-26-52.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-03/image-1679653745321.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-03/image-1679653794003.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-03/image-1679653696211-27-20.png)
[Photos des premiÚres impressions en résine](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-03/image-1679653696211-27-20.png)
Etapes de traitement pour l'impression résine :
\- Enlever à l'aide d'une spatule en plastique les supports collés aux films,
\- DĂ©crocher les systĂšmes des supports,
\- Transvaser le restant de résine dans le conteneur à résine à l'aide d'un filtre pour permettre de filtrer les morceaux,
\- Gratter à l'aide d'une spatule en plastique les morceaux solides encore accrochés aux films,
\- Nettoyer Ă l'aide d'un papier le bac,
\- Laver à l'aide d'un papier et d'un solvant (propanol) le bac de résine,
\- Plonger entre 5 et 15 minutes les piÚces dans un grand volume de solvant afin d'enlever la résine liquide résiduelle,
\- Sortir les piÚces du solvant et les laisser sécher sous la hotte,
\- Rincer Ă l'eau et au savon les spatules, l'entonnoir, le filtre et le support oĂč Ă©taient suspendues les impressions,
\- Exposer ces derniÚres aux ultraviolets naturels ou synthétiques pour durcir les piÚces.
**24/03/2023**
AprÚs avoir récupéré les impressions en résine, nous avons écrit dessus avec un feutre Velleda vert pour savoir si elles étaient effaçables. La réponse est "non". Pourtant au toucher, les surfaces paraissaient lisses. Avec M. Labrousse, nous avons regardé au microscope électronique le trait de Velleda sur le cube en résine. Grùce à celui-ci, nous avons vu des sillons droits apparaßtre au sein de la surface (grossissement x40). Elle est donc poreuse. L'encre reste dans les parties creuses du cube (grossissement x1000). Le microscope possÚde l'option topographie. Nous en avons donc profité pour réaliser la topographie de l'échantillon. Il n'était pas lisse à cause de sa porosité et possÚde un relief. Nous pourrions éventuellement tester l'acétone ou l'éthanol pour regarder si l'encre aurait pu disparaitre sans abßmer l'échantillon
En revanche, il semblerait que les impressions en résine sont plus résistantes que les impressions en PLA. Nous pourrions faire les modÚles correctifs en résine afin de conserver les axes qui restent trop fragiles.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-03/cube-resine-alex-fablab-40.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-03/cube-resine-alex-fablab-1000.jpg)
[Grossissements du cube x40 et x1000](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-03/cube-resine-alex-fablab-1000.jpg)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-03/cube-alex-3d.jpg)
[Topographie d'une surface du cube](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-03/cube-alex-3d.jpg)
L'image supérieure droite montre la coupe sur la surface du cube pour un grossissement x1000. Celle en haut à gauche présente une carte de la surface analysée en fonction de la hauteur. Le bleu vaut 0 micromÚtre et le rouge 18. Enfin, la courbe en bas est la topographie de la surface pour un grossissement x1000.
Dans un second temps, aprÚs avoir reçu le film Velleda, nous avons pu tester la découpeuse vinyle afin de recouvrir les modÚles d'exercices.
Les trois impressions en PLA noir de la semaine derniĂšre ont Ă©tĂ© recouverts de papier Velleda. Sur le logiciel Graphtec Studio, il est possible soit de reproduire les faces des modĂšles soit de crĂ©er un patron. Ici, le cube est recouvert d'un patron exactement aux bonnes dimensions. Le patron du monoclinique est lĂ©gĂšrement plus grand afin de prendre en compte les dĂ©formations dues au pliage. Le rhomboĂšdre est recouvert par 6 losanges. Les patrons semblent plus adaptĂ©s que le collage face par face. Notamment parce que l'une des faces du rhomboĂšdre a Ă©tĂ© perdue. D'ailleurs, exagĂ©rer les proportions du patron n'est pas une bonne idĂ©e. En effet, les pliages sont disgracieux, il faut dĂ©couper ce qui dĂ©passe, ce qui n'est pas Ă©vident. MĂȘme le cutter Ă ultrasons n'est pas pratique pour cette besogne. Il fait fondre le film et lĂ©gĂšrement le PLA. Ces modĂšles rĂ©sistent bien mieux aux chutes depuis un bureau ou plus haut. Par ailleurs, comme le film Velleda est conçu pour ĂȘtre utilisĂ© avec des marqueurs, il n'y a aucun problĂšme pour effacer les Ă©critures. Cependant, le papier film Velleda se colle mal sur le PLA. L'usage de colle est obligatoire pour une utilisation pĂ©renne des modĂšles. Il semblerait que la Loctite 406 adhĂšre mieux sur le plastique. Comme nous souhaitons rĂ©aliser 5 sets de 7 piĂšces, cela va prendre du temps de recouvrir l'intĂ©gralitĂ© de nos systĂšmes. De plus, il existe dĂ©jĂ des modĂšles d'entrainements similaires. Ils sont beaucoup plus gros mais il n'y a qu'un seul set. Ici, plusieurs groupes pourront s'exercer simultanĂ©ment.
Cette solution semble ĂȘtre la plus adaptĂ©e pour notre projet mais nous en discuterons avec M. ChassĂ© lors de notre prochaine entrevue pour savoir si cela lui convient. Si tel est le cas, alors nous utiliserons du PLA blanc pour les modĂšles afin de masquer au maximum les imperfections de collage.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-04/image-1682699172630.png)
[Photo des trois modĂšles recouverts de film Velleda, le cube a des arĂȘtes de 3cm](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-04/image-1682699172630.png)
**31/03/2023**
Aujourd'hui, nous avons rencontré M.Chassé pour faire le point sur l'avancée du projet. AprÚs avoir discuté avec lui, nous avons décidé de faire les systÚmes recouverts de Velleda pour les modÚles d'exercices. A l'inverse, les modÚles de corrections seront réalisés en résine. Nous espérons ainsi qu'ils seront plus résistants que les modÚles en PLA.
A cette fin, nous avons définis des dimensions précises basées sur celles de minéraux pour chaque systÚme pour qu'ils soient facilement reproductibles en cas de perte, de casse ou de vol (*fichiers stl* et *fichiers stl de correction*). Pour éviter au maximum des soucis d'impressions, nous voulions utiliser deux imprimantes pour imprimer les 35 modÚles (7\*5). Cependant, une des imprimantes n'a pas marché donc il n'y en aura que la moitié pour le moment.
Si nous parvenons à terminer rapidement, nous allons ensuite réaliser une boite afin de protéger des chocs, pertes mais également de préserver la colle.
**08/04/2023**
Nous avons eu un problĂšme d'impression sur les 16 modĂšles lancĂ©s la semaines derniĂšre. 7 ont Ă©tĂ© imprimĂ©s mais seulement 3 ou 4 sont exploitables, les autres ont trop de dĂ©fauts pour ĂȘtre recouverts de film. De ce fait, les impressions seront lancĂ©es petit Ă petit les unes aprĂšs les autres, ce qui nĂ©cessitera un temps considĂ©rable.
La découpeuse vinyle aussi a été compliquée à utiliser. Il a fallu demander pour la réalisation des trois tests des semaines précédentes, l'ordinateur d'une personne ayant déjà réussi à la faire fonctionner. D'autre part, comme elle est précise au mm et les impressions à + ou - 0.4 mm, il faudra voir comment cela impacte le recouvrement des modÚles. Par ailleurs, la quantité de film nécessaire pour la bonne réalisation du projet semble plus conséquente que prévu.
En ce qui concerne la colle, le cube et le rhomboÚdre ont été enduits de cette derniÚre puis malmenés pendant 7 jours. Au terme de la semaine, aucun décollement n'était repérable.
**12/04/2023**
Les modĂšles d'entrainements sont tous soit en cours d'impression soit terminĂ©s. Il faudra juste les recouvrir. La dĂ©coupeuse vinyle ne fonctionne pas. Le logiciel conçu pour communiquer entre la dĂ©coupeuse et un ordinateur est Graphtec Studio. Cependant, il est impossible de faire communiquer un pc avec la dĂ©coupeuse. Que ce soit celui d'Alexandre, les ordinateurs portables du Fablab ou bien la tour installĂ©e spĂ©cialement pour la dĂ©coupeuse. Pourtant celle-ci fonctionne. AprĂšs avoir testĂ© plusieurs logiciels, il semble compliquĂ© d'identifier la source du problĂšme. C'est embĂȘtant puisque la dĂ©coupeuse impacte directement le bon dĂ©roulement de notre projet.
**14/04/2023**
Une impression en résine a été réalisée jeudi pour les modÚles cristallins avec axes et plans miroirs aux bonnes dimensions. De ce fait, leur volume est plus conséquent. En outre, les axes ont été épaissis et leurs longueurs raccourcies afin de limiter la casse sur le long terme.
Malheureusement, nous avons minimisé le volume de résine nécessaire à l'impression. De ce fait, les modÚles ont été partiellement imprimés. Pour pallier à cette erreur, un nouveau rendez-vous est fixé à la semaine prochaine.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-04/image-1682094463344.jpg)
[Photo de l'échec d'impression en résine](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-04/image-1682094463344.jpg)
La pose des éléments de symétries sur le systÚme rhomboédrique est terminée. C'était le seul manquant.
D'autre part, tous les modÚles d'exercices sont imprimés. Il y a au final 7 sets de 7 piÚces.
[
Photo de toutes les impressions d'entrainements](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-04/image-1682094479253.jpg)
Avec Pierre, nous avons discuté des différentes possibilités pour la fabrication de la boite, sous réserve que nous disposions de temps :
\- boite en bois avec couvercle de plexiglass pour voir correctement les modĂšles,
\- mousse prédécoupée reprenant la forme des impressions,
\- noms des modÚles gravés sur le plexiglass.
Enfin, comme la semaine derniÚre, la découpeuse vinyle refuse toujours de fonctionner. Nous allons devoir envisager de faire toutes les découpes à la main. Il va falloir remédier à ce problÚme au plus tard la semaine prochaine afin de commencer la pose du Velleda.
Suite Ă un nouveau rendez-vous au Fablab Chimie, les systĂšmes cristallins ont Ă©tĂ© imprimĂ©s en rĂ©sine blanche. Contrairement au premier modĂšle, nous avons Ă©paissi les axes et accentuĂ© les encoches des plans miroirs. Cependant, les modĂšles ne sont pas parfaits. En effet, on observe des modifications de l'Ă©tat de surface. Les faces ne sont pas parfaitement tabulaire dus Ă diffĂ©rents facteurs. Tout d'abord, l'imprimante repose sur une table de laboratoire dans un endroit de passage. Ainsi, les vibrations suscitĂ©es par l'environnement ont pu ĂȘtre enregistrĂ©es sur certaines couches. De plus, les modĂšles Ă©tant denses (car ils sont pleins), il aurait fallu augmenter la densitĂ© des supports pour Ă©viter un affaissement de la matiĂšre du Ă la gravitĂ©. Aussi, on peut remarquer des marques de supports Ă certains endroits des figures. Pour palier Ă ces imperfections, nous pourrions essayer d'imprimer les modĂšles sous une hĂŽte qui a la particularitĂ© d'absorber les vibrations que subit l'imprimante. Ou sinon, placer l'imprimante sous un tapis de mousse pour limiter les secousses. Concernant les supports, il faudrait trouver le bon compromis entre des supports peu denses qui ne laisseraient aucune trace sur les modĂšles et des supports denses qui permettraient un meilleur maintien.
Les modĂšles ci-dessous ont Ă©tĂ© placĂ©s 2h aprĂšs impression sur le rebord d'une fenĂȘtre pour qu'ils continuent de se solidifier Ă l'UV.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2023-05/image-1683752785044.jpeg)
ModÚles avec éléments de symétries imprimés à la résine
[![i