🎛️ UE 5Ci803 - Optimisation et contrôle des procédés Aquarium et régulation de la qualité de l'eau Informations Camille Guillet, Amel Gaci, Sabrina Akour, Andjela Zlatkovic, Anis Sakka email : camille.guillet.2@etu.sorbonne-universite.fr UE 5CI803 15/12/2022 - 31/01/2023 Contexte Nous cherchons à effectuer la régulation et le contrôle de la qualité de l'eau d'un "aquarium " dans le cadre de notre UE 803 'optimisation et contrôle des procédés. Objectifs - construire un aquarium avec les outils à disposition - Réaliser une régulation de la qualité de l'eau : contrôler la turbidité, le niveau d'eau et la température - Mettre au point et Réaliser un dispositif expérimental et un schéma electronique avec Arduino Vue filaire de notre aquarium avec les cloisons incorporées Vue ombrée de notre boîte d'aquarium Matériel 2 planches de CP peuplier 5mm (dimensions 280*580mm) Plexiglas Silicone Capteur Turbidité et niveau eau Pompes eau et pompe air Tuyaux Sonde de Température immergeable elctrovanne, servomotor Switch A/N, cables, adaptateur 12V Machines utilisées - Découpe Laser - pistolet à colle Construction Étape 1 Construction du bocal Aquarium : utilisation logiciel découpe laser Étape 2 Construction support en bois : découpe planche et gravure Étape 3 Réalisation montage electronique (Arduino) Étape 4 : finalisation aquarium : collage (avec colle pour Glue, mais mieux d'utiliser colle PMMA acrylique pour Plexiglas) , joints de colle ( ça aurait été mieux avec des bons joints de silicone) installation des pompes et vannes, tuyaux Étape 5 : Code Arduino et test electronique Étape 6 : Installation finale:  réservoir source et évacuation eau et tests Étape 7 : Démonstration Journal de bord 15/12/2022 Brainstorm et définition des dimensions du bocal: 25  x 20 x 15 (cm) et matériau (Plexiglas) : transparent, résistant au poids de l'eau et suffisamment inerte, d'épaisseur 3mm. Utilisation logiciel Festi pour générer les dimensions de la boite 16/12/2022 Utilisation outil découpe laser et assemblage plaques Plexiglas : début de construction aquarium 03/01/2023 Brainstorm sur la filtration et agencement des outils et dispositifs Code pour Arduino : début Découpe planche bois pour support et gravure Poursuite construction de l'aquarium 06/01/2023 Codage Arduino Début Montage composants électroniques 09/01/2023 Montage electronique, Arduino: branchages chaque pompe est contrôlée par un relai 5V:  les pompes sont alimentées par un courant de 12V (air et eau) ou 3V pour la pompe immergée. Les capteurs sont reliés à du 5V : le capteur de turbidité a une sortie analogique (reliée à A0), celui de niveau d'eau digitale ( relié à un pin 8). La ligne d'alimentation du bas de la platine d'essai est réalisé par  le microcontroleur en 5V, et permet d'alimenter les capteurs et les relais. La 2ème ligne d'alimentation est alimentée en 12V par un adaptateur 12 branché sur secteur. L'alimentation de la pompe immergée en 3V est réalisé par l'alimentation du controleur via une autre platine d'essai Collage, Joints de la boite de l'aquarium : début des joints : à poursuivre : les dimensions des 2 parois de Plexiglas séparant les compartiments sont de même dimension mais les plaques de Plexiglas ne sont pas placées au même niveau : h x l x e : 11cm x 19,6 cm x 3mm Agencement des différentes parties, scotchage 17/01/2023 Avancement montage electronique 20/01/2023 réalisation 2ème planche CP Peuplier, mise en place des tuyaux, test des diamètres d'installation du capteur niveau d'eau 24/01/2023 Détermination du diamètre trou capteur d'eau d=21,3mm et de la position : environ 12,5 cm depuis le bas , plus ou moins vers le 1er tiers de la longueur. Collage des bords de l'aquarium, sauf dernière avec le trou, problème de collage et assemblage (changement de colle entre les 2) : on n'a pas réussi à bien tout assembler de manière jointive. En voulant arranger le problème, (on a voulu enlever la plaque collée très fortement) on a cassé la plaque. Donc, refabrication de la même plaque la fois d'après. Les cloisons entre les compartiments sont au nombre de 2 ( mêmes dimensions, cf 09/01) Une 1re cloison séparant le bac principal ( Aquarium) et le compartiment de "filtration" : cette plaque est collée de la base (20 x 20 cm) de l'aquarium, perpendiculairement aux 2 parois longitudinales ( parallèlement à la paroi latérale)  par la tranche de 3mm: cette plaque de 11cm permet le débordement de l'eau par dessus la plaque pour passer sur le filtre à café installé. Elle est installée à partir de 3,5 cm environ de la paroi latérale de l'aquarium. Une 2ème cloison est également installée parallèlement à 2cm de la première et à 1,2 cm  environ de la paroi latérale de l'aquarium. celle ci est collée de telle manière que le haut de la paroi est à  15cm de haut : il y a donc h1=15-11-0,3=3,7 cm d'espace entre la base de l'aquarium et la cloison. Celle ci permet de séparer l'espace "filtration" et l'espace de pompage/évacuation de l'eau. La plaque est donc collée sur 2x11 cm sur les parois latérales. Le filtre à café sera installé à la toute fin entre ces 2 "cloisons" pour permettre à l'eau transvasante et de se déverser dessus et de la filtre : l'eau s'écoule du haut vers le bas et l'eau en aval du filtre est donc filtrée et évacuée par la pompe à eau (le filtre permet d'éviter de boucher les tuyaux et la pompe) 26/01/2023 Fabrication d'une nouvelle plaque plexiglas pour la dernière paroi de l'aquarium, assemblage pas jointif encore avec le test de colle. On a finalement juste pris de la colle pour faire des joints d'étanchéité et pour boucher un peu les trous de la dernière longueur. Pour les fuites, on mettre notre boite d'aquarium dans un récipient plus grand pour les fuites ( cf Jérome ) Test du capteur de turbidité : valeur de la tension pour la turbidité est de 4,3V (cf code):  test dans une bouteille d'eau transparente, de l'eau d'abord limpide ( U=4,6V) puis ajout de jus de clémentine pour augmenter la turbidité petit à petit. On a fixé la valeur de turbidité maximale avant la régulation du système. Début de test des pompes. 27/01/2023 Test des pompes : Matériel limité pour les pompes : -pompe à air 12V: Contrôlée par un relai et alimentée 12V : la pompe permet d'ajouter de l'air dans l'aquarium, test de son fonctionnement et de son contrôle -pompe à eau immmergée, 3V : la pompe est placée dans un réservoir d'eau qui est une source d'eau pure - pompe à eau,12V permettant l'évacuation de l'eau par le compartiment de pompage : Finalisation 2ème planche en bois pour  support, collage et joins, collage filtre à caféRégulation de pH La régulation du pH Objectif du projet : Le projet consiste à réguler le pH d’une certaine solution (acide ou basique) en utilisant un programme Arduino. L’idée vient du problème de neutralisation des rejets liquides industriels qui consiste une étape primordiale dans le traitement des déchets. Le matériel utilisé : - 4 bouteilles en plastique (2 réservoirs pour l’acide et la base, un réacteur, et un tank). - 3 électrovannes associées à des relais. - Une sonde de pH - Une Tige d’agitation associé à un moteur - Un afficheur - Un indicateur de niveau - Un Arduino avec une plaque d’essai - Des files et des tuyaux en plastique - Un support en bois Les appareils utilisés : - Découpeuse Laser - Perceuse à colonne - Scie électrique - Imprimante 3D - Des outils manuels ( pistolet à colle, perceuse, viceuse à main,…) Les étapes de construction : Étape 1 : Construction du support Nous avons utilisé 4 plaques ( 6030 cm^2) pour avoir un support 9060. Étape 2 : Mise en place des réservoirs Nous avons fixé d’abord les 2 réservoirs des solutions acide et base. Ensuite, nous avons fixé le réacteur et le tank. Enfin, nous avons fait des trous pour faire passer les tuyaux. Étape 3 : Mise en place des électrovannes Nous avons placé les électrovannes à la sortie des deux réservoirs ainsi que le réacteur. Nous avons associé à ces dernières des relais. Étape 4 : Impression de la tige Nous avons fait le design de la tige en utilisant le logiciel Tinkercad, et ensuite nous avons utilisé l'imprimante 3D. Enfin, nous avons relié la tige au moteur. Régulation et mesure de la couleur par spectrophotométrie Régulation et mesure de la couleur par spectrophotométrie en utilisant Arduino Le concept de ce projet est de pouvoir produire un ensemble de couleurs spécifiques par le mélange des trois couleurs primaires (Rouge, Jaune et Bleu) utilisées pour produire ces dernières, cela sera possible par l'utilisation d'un spectrophotomètre qui mesure la couleur de l'échantillon de départ que nous avons (transparent par exemple) ce qui permet au système de savoir quelle quantité des couleurs primaires doit être administrée pour notre résultat final, le spectromètre effectuera ensuite une seconde mesure pour évaluer la qualité de la couleur et si c'est bien le résultat escompté, avec une petite marge d'erreur qui, si elle est dépassée, l'échantillon est administré en quantités appropriées pour atteindre la marge d'erreur acceptée. Le choix des couleurs utilisés pour le mélange est plutôt simple, le RYB (rouge-jaune-bleu, Red-Yellow-Blue en anglais) est un ensemble historique de couleurs utilisé dans le mélange soustractif de couleurs, et est un ensemble de couleurs primaires couramment utilisé. Elle est principalement utilisée dans l'enseignement de l'art et du design, notamment en peinture. Les RYB constituent donc les critères de couleur primaire, en concevant la roue chromatique standard de l'artiste. Le secondaires (violet-orange- vert) constituent une autre triade. Les couleurs de la triade (violet-orange- vert) parfois appelée (violet-orange- vert) constitue une autre triade. Les triades sont formées par trois couleurs équidistantes sur une roue de couleur particulière. Pour créer une large gamme de nouvelles couleurs, les couleurs primaires peuvent être mélangées en utilisant différentes quantités de couleurs proportionnelles les unes aux autres. Mélanger des peintures, des pigments ou des colorants en utilisant des formules de mélange de couleurs proportionnelles garantit qu'une couleur spécifique peut être reproduite, ce qui permet à un artiste d'assurer la cohérence et la prévisibilité du mélange des couleurs. Le mélange proportionnel des couleurs peut impliquer des rapports simples, comme utiliser deux fois plus de rouge que de jaune, ou des formules complexes, comme mélanger une partie de rouge, deux parties de bleu et trois parties de jaune. Chaque combinaison produira un résultat nouveau et intéressant. L'image de mélange de couleurs jointe ci-dessous présente quelques formules de mélange proportionnel de couleurs. Pour appliquer cette logique à notre idée de projet, nous utiliserons bien sûr l'Arduino pour le stockage interne d'instructions pour la mise en œuvre de fonctions telles que la logique, le séquençage, la synchronisation, le comptage et l'arithmétique pour contrôler, par le biais de modules d'entrée/sortie numériques ou analogiques, différents types de composants qui constituent notre système.  L'image jointe ci-dessous montre un schéma fonctionnel de ce dernier. Le mélange dans le récipient sera soit géré par arduino également, soit nous pourrions utiliser un mélangeur magnétique manuellement. Le premier modèle : Spectromètre MIKROE-4165 Led blanche Breadboard La première option est assez simple, une source de lumière normale avec un capteur spectromètre qui, comme son nom l'indique, détecte les différents spectres de la lumière avec un prix élevé à payer pour cette commodité. Partie Régulation : Électrovannes LEX-VALVE2 Relais Électrovanne Relais La partie Régulation est assez simple en ce qui concerne le matériel, les électrovannes étant utilisées comme moyen d'administrer les pigments de couleur avec précision pour obtenir les résultats souhaités. Conception du support du projet Matériel utilisé : Trois goblets en plastique Tuyaux de 8 mm de diamètre. Planches en bois faible épaisseur (5-6 mm d’eppaisseur) pour le decoupage laser. 16 visses M5 16 écrous M5 4 équerres Appareils utilisés : Découpeuse Laser Perceuse à colonne Imprimante 3D Logiciels utilisés : Blender (Pour la conception 3D). Ink Scape (Puisque la découpeuse laser à besoin d'un fichier au format svg). IdeaMaker (Pour le découpage du modèle 3D). Des supports pour le spectrophotomètre et d'autres composants étaient nécessaires, le composant principal étant une plateforme utilisant trois planches dont deux ont les dimensions suivantes (28x20 cm) et ont été utilisées comme support pour où la carte Arduino, la boîte du spectrophotomètre et les récipients à trois couleurs, les deux planches étant collées sur la plus grande planche (58x28 cm). Ce dernier étant conçu à l'aide d'une découpeuse laser. Le capteur du spectromètre n'ayant besoin que d'une seule source de lumière, il lui fallait un boîtier fermé faisant face à la source de lumière (LED blanche) pour capter la lumière traversant la cuvette remplie de son contenu coloré, voici des photos dudit boîtier modifié à l'aide du logiciel de modélisation gratuit Blender. Boitier Spectromètre dans Blender Boitier spectromètre avec composants Un problème que nous avons rencontré lors de cette phase est le problème de mélange des couleurs administrées, d'autant plus que la cuvette est très petite et ne peut pas entrer dans n'importe quel appretus de mélange, la solution que nous avons trouvé est une sorte de mélangeur en forme d'embout qui regroupe les trois tuyaux qui viennent des électrovannes et les condense en une seule sortie où les trois couleurs mélangées sont versées à l'intérieur de la cuvette, sa conception a également été rendue possible en utilisant le logiciel de modélisation Blender. Mixeur dans Blender Mixeur imprimé Montage : Pour le montage, on a placé nos gobelets, qui contiendront chacun un de nos 3 colorants, en hauteur sur la plateforme. Nos gobelets sont liés à nos électrovannes via des tuyaux en caoutchouc, et ces mêmes électrovannes sont liées à un mélangeur de la même manière. Nous avons utilisé un embout d’aspirateur pour voiture comme base pour fabriquer notre mélangeur. Le liquide, après être passé dans le mélangeur, entrera dans la cuve afin d’être analysé par le spectrophotomètre. Notre montage est fait de sorte à ce que la gravité suffit à acheminer notre liquide jusqu’à la cuve. Nos électrovannes sont reliées à des relais qui seront fixés à proximité sur la plateforme (juste en dessous). Les relais serviront à gérer le passage du courant vers l’électrovanne, et donc à gérer son ouverture. Ces relais sont branchés directement sur un breadbord, qui sera posé à la base de notre support. Ce breadbord sera, quant à lui, lié à la carte mère de notre spectrophotomètre. Le breadbord est un outil qui nous servira à lier plusieurs éléments (ici nos relais et notre spectrophotomètre) sans avoir à faire de soudure. Cette carte mère sera elle directement liée au capteur afin de pouvoir traiter les données reçues par le capteur dans le boitier sur le mélange de colorant dans la cuve. L’alimentation en électricité de notre système se fait via la carte mère du spectrophotomètre. Il est nécessaire d’avoir une alimentation assez puissante afin de pouvoir faire fonctionner le circuit. Nous avons au début eu des problèmes à ce niveau car nous avions fait l’erreur d’alimenter le circuit via la batterie d’un ordinateur portable. Pour résumer, toutes les composants ou le liquide place a été placé en hauteur à différent niveau de sorte à ce que la gravité soit une force motrice suffisante pour le déplacer. Le reste a été placé à la base car plus pratique (sauf les relais qui doivent être à proximité des electrovannes). Logique du code utilisé : Ce code est écrit dans le langage de programmation Arduino et utilise l'environnement de développement intégré (IDE) Arduino. Le code met en œuvre un système de contrôle simple pour contrôler l'intensité des relais électromagnétiques DC rouge, jaune et bleu afin de créer une couleur désirée. Le code comprend plusieurs bibliothèques, notamment la bibliothèque Wire.h qui fournit une interface TWI/I2C pour la communication entre le microcontrôleur et le capteur AS7341. Les bibliothèques Adafruit_Sensor.h et Adafruit_AS7341.h fournissent le support pour le capteur que nous avons, qui est utilisé pour mesurer les valeurs RGB d'un échantillon de couleur, bien que le nôtre ne soit pas exactement un capteur Adafruit, nous avons pensé que puisqu'ils utilisent le même type de capteur, il peut suivre la même logique et fonctionnalité. Les broches pour les relais DC électromagnétiques sont définies en utilisant la directive #define du préprocesseur, et la broche de la LED blanche est également définie. Une instance du capteur AS7341 est créée en utilisant Adafruit_AS7341 sensor = Adafruit_AS7341() ;. Dans la fonction setup(), la communication série est initialisée, les broches du relais et de la LED sont initialisées comme sorties, le capteur AS7341 est initialisé et la couleur désirée est lue sur le clavier. La fonction loop() mesure en continu les valeurs RVB d'une couleur échantillon à l'aide du capteur AS7341 et calcule l'erreur entre la couleur souhaitée et la couleur mesurée. En fonction de l'erreur, la quantité de chaque colorant est mise à jour pour minimiser l'erreur, et les relais électromagnétiques DC sont activés ou désactivés en conséquence. Le code attend 100 millisecondes dans la fonction loop() avant de répéter le processus de mesure et de contrôle. Look final du projet : Après le montage correct de tous les composants, le projet était terminé et il ne manquait plus que le code pour l'exécution, le problème résidait dans les bibliothèques ou plutôt dans la mauvaise utilisation de ces dernières lors de l'écriture du code, la logique de ce dernier reposait sur les capacités du capteur à donner les données directement dans un format RGB, une tentative quelque peu délicate qui nécessitait d'autres ajustements. Une autre logique possible que nous aurions pu poursuivre était d'avoir une sorte de banque de données qui a tous les spectres d'absorption stockés dans lequel il peut être consulté pour reconnaître et produire la couleur, une fonction tout à fait prévisible que ce capteur est capable d'un tel exploit. Ces deux voies ont nécessité un temps considérable dont nous manquions fortement, le développement de ce code est donc nécessaire au bon fonctionnement de l'appareil. Les fichiers STL de l'impression ainsi que le fichier Arduino contenant le code sont accessibles en cliquant ici.Machine à Cocktail UE 803 - Optimisation et Contrôle des Procédés - Master 2 - Ingénierie Chimique Projet Expérimental Arduino Dans le cadre de cette UE, nous devons réaliser un projet de régulation par prototypage utilisant principalement un micro contrôleur Arduino et des capteurs / actionneurs. Après quelques séances de brainstorming et échange d'idées, nous avons décidé d'opter pour la conception d'une machine à cocktail connecté via assistant vocal. Des pompes gèreraient le débit des boissons et un capteur pour la détection d'un gobelet serait ajouté. Nous avons passé en revu plusieurs projets de système de pompage utilisant Arduino ou un connecteur Nano-IoT et avons donc pu dresser une liste du matériel complet pour mener à bien ce projet. Projet distributeurs de boissons Objectif : Réaliser un distributeur de cocktails à partir de 7 boissons (et donc 7 pompes) qui nous permettrait de faire différents mélanges. Le distributeur serait connecté au cloud via un Nano-IoT et contrôlé vocalement par Alexa. Matériel électronique : 7 pompes 7 relays (ou switch) fils de connexions Un nano 33 IoT Une carte arduino Une platine Câble d'alimentation Câble usb relié à l'arduino Câble usb relié l'IoT Un capteur sonar (distance) 4 Boutons poussoirs 4 Résistances Matériel de construction : Tuyaux Planches de bois Vis 7 Bouteilles vides 1,5L Premier Brouillon : ____________________________________________________________________________________________________________ Semaine 6 au 13 Décembre : Une fois tout le matériel reçu, la première étape du projet a été de mettre en place une stratégie pour monter et faire fonctionner les pompes : Mettre en place le schéma de branchement des pompes Faire un état des lieux des fils nécessaires (bruts, embout femelle, embout male). Dénudé la quantité de fils nécessaire Trouver la borne + et la borne - des pompes en utilisant un multimètre Après plusieurs recherches et la consultation de plusieurs sites web et pages github, le branchement suivant reliant la pompe, le relay et l'arduino a été déterminé comme celui qui serait utilisé : L'utilisation d'un relay est essentiel si nous voulons être capable de faire varier l'intensité de la pompe ou sa durée de fonctionnement. En effet la pompe est par défaut une entité booléenne : allumée ou éteinte. Soudure des fils à nos 7 pompes : Branchement des fils de connexions aux 7 relays : Branchement final des pompes aux relay puis sur la carte Arduino : Semaine 2 Janvier : Une fois les pompes câblés correctement et branchées, nous devons commencer à programmer nos commandes de boissons, car sinon les pompes sont activés en continues quand connecté à l’alimentation. Nous recherchons donc des exemples de codes qui montrent comment activer une pompe pour un délais précis et initialiser notre setup en fonction du nombre de pompe utilisées. Un de nos premiers exemple de code utilisé est celui-ci : Nous arrivons donc maintenant à activer une pompe et contrôler sa durer d’activation. Le but est d’ensuite ajouter toutes nos pompes et crée des fonctions qui gèrent l’activation de 2 pompes en même temps gérer par une seule fonction « boisson »pour réaliser les mélanges de nos cocktails. Nous cherchons également en parallèle comment se branche et fonctionne notre capteur sonar de distance. En effet après plusieurs recherches nous nous sommes rendu compte que notre capteur ne possède pas les branchements décrit habituellement dans la littérature et autres projet libre d’accès. En effet, dans nos nombreuses recherches de fonctionnement du capteur nous retrouvions tout le temps le capteur ci-dessus. Qui possède quatre branchements : Vcc qui correspond au voltage 3,3 ou 5V, GND qui correspond comme l'indique son nom à la terre (ou ground). Et finalement les branchements Trig et Echo où Trig correspond au transmetteur soit la partie de gauche qui va émettre des impulsions qui seront arrêtées et renvoyé par l'objet qui fait face au capteur. Ces impulsions renvoyées sont captées par le récepteur qui correspond à l'Echo (partie de droite). Cependant, nous ne sommes pas exactement dans ce cas-là. Ici, les sorties Trig et Echo sont remplacés par la sortie SIG qui fait office de branchement pour le transmetteur et le récepteur et sera branché sur le pin digital dans notre cas le pin 10. La sortie NC (ou "not connected") est comme l'indique son nom une sortie qui n'a pas besoin d'être relié à quoi que ce soit. GND et VCC sont des branchements qui se font à l'identique de ce qui a été expliqué précédemment. Le branchement de notre capteur est donc simplifié mais il a fallu faire un travail d’identification pour assurer une connexion. Branchement capteur : Semaine 9 Janvier : Nous avons pu réaliser les branchements du capteur et les avons reliés correctement à l’Arduino. Nous devons désormais adapter notre code afin de spécifier les fonctions liées au fonctionnement du capteur mais aussi ajouter une nouvelle condition sur l’activation des pompes : les pompes ne peuvent s’activer que si le capteur détecte une présence proche à moins ou égale à 2cm de distance du récepteur du capteur. Nous nous penchons également sur le Nano-IoT fait pour relier notre système au service cloud de Arduino afin de créer des boutons digitaux (web ou application mobile) contrôlable manuellement ou par assistanats vocaux grâce à la configuration de ces boutons digitaux en skills Alexa. Pour ce faire nous commençons à souder les branches en or fournis avec note Nano-IoT 33 pour pouvoir faire des branchement. Une fois fait, il est connecté sur une platine et branché par un câble USB à l’ordinateur pour la création des boutons et du code associé. Nano IoT : Après soudures : Nous cherchons dans la documentation Arduino le nom des connexions disponible sur notre connecteur bluetooth car ils ne sont pas inscrit sur notre appareil : Une fois les soudures réalisées et la documentation en notre possession, nous pouvons tenter de recréer les connexions réalisées précédemment sur l’Arduino avec une pompe sur le Nano-IoT afin de commencer à comprendre le fonctionnement du service cloud. Nous souhaitons avoir 7 boissons, donc 7 boutons, qui vont activer des jeux de pompes différentes, nous créerons donc nos boutons auxquels nous relions des variables booléenne (TRUE or FASLE) qui gèrent l’état des boutons « Appuyer ou Étein » et devons coder dans la partie du code auto généré par Arduino Cloud pour contrôler l’action réaliser après activation des boutons. Après plusieurs recherches sur le fonctionnement d’Arduino Cloud et du IoT nous associons notre appareil à leur application, et nous nous connectons à un réseau wifi privé et sécurisé. Nous pouvons alors créer  nos « things » qui sont nos variables qui vont gérer l’allumage des pompes et donc la création des boissons. Nous commençons d’abord à travailler avec une seule pompe et sans capteur pour bien comprendre comment marche cet appareil. Nous avons alors crée nos 4 variables pour 4 boissons, et n’allons travailler que sur la boisson 1 avec une seule pompe pour l’instant. Nous pouvons alors passer à la suite et créer nos boutons virtuels, on associe alors les variables créees précédemment à chaque boutons. Nos variables sont définies comme booléenne, read & write et sa valeur est actualisée à chaque changement d’état du bouton. Arduino Cloud nous auto crée alors une partie de code où nous avons plus qu’a ajouter nos fonctions de contrôle des pompes. Dans la photo ci-dessous le code n’est pas correcte, mais nous avons utilisé le code montré précédemment, utilisé pour la carte Arduino. Nous avons vérifié la syntaxe et télévisé le code sans aucun problème. Les boutons devraient donc marcher. Par la suite nous créons donc les skills Alexa nécessaires pour le contrôle vocal de l’activation des boutons crées précédemment, codé et associé à l’IoT. Le code marche sur l’arduino, les boutons sont reliés au variables, le code transféré à l’IoT à la bonne syntaxe compatible Cloud Agent et le téléversement se fait « succesfully » et sans erreur, malheureusement impossible de connecter le IoT au cloud. Il reste « Hors ligne » en permanence. Normalement après le téléversement, le IoT est sensé se connecter immédiatement au cloud et être « Online », nous avons vu une connexion de 1 seconde puis déconnexion immédiate. Après plusieurs recherche il se peut que le réseau cloud de Arduino soit en maintenance ou inaccessible. Nous avons essayé plusieurs réseau différents par la suite, et malgré le téléversement réussi et une connexion privé, notre IoT ne se connecte pas au Cloud, impossible donc d’activer les boutons sur le site web et encore moins à distance avec Alexa. Après de nombreuses tentatives infructueuses cette semaine, et le fait que ni l’université ni le fablab ne possèdent de réseau wifi privé auquel nous pourrions nous connecter pour présenter la machine lors du rendu final, nous décidons d’abandonner l’idée de contrôle par assistant vocal ou de boutons virtuels. Il faut alors trouver une autre solution. Semaine 16 Janvier : Nous arrivons plus ou moins à faire marcher le capteur et une pompe, mais pour l’instant nous n’arrivons pas à spécifier la condition && du fonctionnement des 2 pompes en même temps que le capteur. Nous travaillons donc a améliorer le code et tenté de trouver une version qui fonctionne. Cette semaine nous commençons également à avancer sur la structure : nous avons fait un état des lieux et avons défini que nous avions besoin d’un bac pour récuperer le liquide sous le verre, d’une partie haute qui dispense le liquide et qu’un « réservoir » qui contiendrais nos bouteilles et doit etre accessible pour les changer ou faire une maintenance des équipements. Le capteur, les pompes et le arduino avec la platine ce trouveraient à l’interieur de la machine, au dessus des bouteilles d’ou sont pompé les liquides. Un premier croquis est suggéré : Le bac d’écoulement du liquide au cas où des goutes couleraient à coté lors de la distribution de boisson est assez indépendant de la machine et peut être rajouté seule, nous commençons donc a réfléchir à un design de conception pour commencer par cette pièce, étant donné que le code n’est pas définitif nous ne préférons pas avancer de suite sur la structure définitive. Le bac d’écoulement était initialement prévu en bois tout comme le reste de a structure de la machine mais ce matériaux n’est pas hydrophobe et se gorgera d’eau s’il est en contact avec. A la fin de cette séance fablab nous décidons donc de partir sur du plastique PMMA de 3mm d’épaisseur et de couleur noir (pas transparent car nous verrions le liquide à travers, ce qui n’est pas très esthétique dans ce cas). Nous commençons donc par réaliser une fichier vectoriel 2D grâce au logiciel Inkscape afin de dessiner les bordures de nos pièces en vue d’une découpe laser. Dans un premier temps nous optons pour un porte gobelet de 10x10cm et avons réaliser le fichier suivant pour la découpeuse laser : Semaine 23 Janvier : Coté code, nous arrivons finalement à faire fonctionner une pompe d'après la condition de distance sur le capteur que nous avions spécifié à moins de 3 cm. Nous pouvons alors tenter de reproduire les branchements pour toutes nos pompes et commencer à structurer notre code avec les pompes correspondant aux boissons souhaitées. Faisant face à des problèmes pour travailler avec le Nano-Iot comme nous le souhaitions, nous avons cherché en parallèle une alternative pour proposer nos différentes boissons. Et pour cela, nous avons décidé de travailler avec des boutons poussoirs. C'est aussi à ce moment qu'il nous a semblé judicieux de nous limiter dans le nombre de pompes en passant de  7 à 4 pompes ce qui nous permettait aussi d'avoir un plus petit montage à réaliser pour notre design. Remarque : Un fil GND (Noir) et un fil 5V (Blanc) sont reliés de l'arduino vers la platine respectivement sur la bande moins et la bande plus. Tous les fils devant être reliés au GND seront donc sur la ligne des moins et ceux devant être reliés au 5V seront sur la ligne des plus. Nous arrivons à réaliser un premier montage pour activer une pompe à l'aide d'un bouton, mais nous éprouvons quelques problèmes pour le code pour apposer la condition && entre le capteur et le bouton. En effet, nous souhaitons que la pompe s'active si et uniquement si l'obstacle se trouve à moins de 3 cm du capteur et si le bouton a été activé. En essayant une condition if ((bouton == 0) && (cm<3)), nous remarquons que le bouton n'est pas pris en compte dans l'activation de la pompe. Pour finalement faire fonctionner nos deux conditions, il nous a fallu déclarer nos conditions comme des variables "boolean" dites aussi "tout ou rien". C'est ce qu'il est possible de voir en rouge dans le code correspondant au montage (a). Cela nous permet d'indiquer à l'arduino que nous avons deux états pour chacune de nos variables : état 0 où le bouton n'a pas été activé et où le capteur ne repère un obstacle à moins de 3 cm et l'état 1 où le bouton est activé et le capteur identifie bien un obstacle à moins de 3 cm. const int pingPin = 7; const int pumpPin2 = 2; // // le relais est connecté à la broche  de la carte Adruino const int bouton1 = 3; boolean boutonappuye1; boolean proche; void setup() { // initialize serial communication: Serial.begin(9600); // The PING))) is triggered by a HIGH pulse of 2 or more microseconds. // Give a short LOW pulse beforehand to ensure a clean HIGH pulse: pinMode(pumpPin2, OUTPUT); pinMode(bouton1,INPUT); } void loop() { // establish variables for duration of the ping, and the distance result // in inches and centimeters: long duration, inches, cm; // The same pin is used to read the signal from the PING))): a HIGH pulse // whose duration is the time (in microseconds) from the sending of the ping // to the reception of its echo off of an object. pinMode(pingPin, OUTPUT); digitalWrite(pingPin, LOW); delayMicroseconds(2); digitalWrite(pingPin, HIGH); delayMicroseconds(5); digitalWrite(pingPin, LOW); pinMode(pingPin, INPUT); duration = pulseIn(pingPin, HIGH); // convert the time into a distance inches = microsecondsToInches(duration); cm = microsecondsToCentimeters(duration); Serial.print(cm); Serial.print("cm"); Serial.println(); boutonappuye1 = digitalRead(bouton1); Serial.println(boutonappuye1); proche = (cm<3); if (boutonappuye1 && proche) { digitalWrite(pumpPin2, LOW);// la pompe à eau remplit la bouteille } else { digitalWrite(pumpPin2, HIGH); // la pompe à eau s'arrête } } long microsecondsToInches(long microseconds) { // According to Parallax's datasheet for the PING))), there are 73.746 // microseconds per inch (i.e. sound travels at 1130 feet per second). // This gives the distance travelled by the ping, outbound and return, // so we divide by 2 to get the distance of the obstacle. // See: https://www.parallax.com/package/ping-ultrasonic-distance-sensor-downloads/ return microseconds / 74 / 2; } long microsecondsToCentimeters(long microseconds) { // The speed of sound is 340 m/s or 29 microseconds per centimeter. return microseconds / 29 / 2; } Remarque : Ce code fonctionne de telle manière qu'il indique que lorsque le capteur détecte un obstacle à moins de 3 cm et le bouton est appuyé alors la pompe est allumé. Cependant d'après le code c'est l'inverse qui devrait se passer puisqu'il est indiqué que la pompe est en "LOW". Nous expliquons cela par le fait que des branchements sont inversés et inversent donc la consigne. A partir de ce premier code, nous pouvons donc activer les pompes lorsque la condition du capteur et du bouton est respecté et si l'on s'éloigne assez du capteur ou si nous arrêtons d'appuyé sur le bouton alors la pompe s'arrête. Nous souhaitions qu'une fois que le bouton n'est pas besoin d'être pressé en continue pour obtenir notre boisson. nous avons rajouter des "delay" pour activer les pompes un temps donné. Dans ce cas, le capteur et le bouton restent bloqués en position 1 tant que le delay n'est pas arrivé à termes, cela signifie que nous ne pouvons pas arrêter la pompe lorsque  les deux conditions sont réunis une fois. Coté design nous choisissons une version un peu plus définitive du modèle final de la machine et faisons l’inventaire des planches et tailles de planches nécessaires : Nous prévoyons donc d’utiliser une planche intermédiaire en hauteur afin de fixé les pompes à coté de l’arduino et de dédier un espace spécifique pour les bouteilles et les tubes. Cependant, nous voyons d’or et déjà que nous n’allons pas avoir assez de tube en plastique fournis. Effectivement nous n’avons qu’un seul mètre de tube pour un total de 4 pompes au final, dont 1 tube dois descendre tout au fond de la bouteille, et l’autre ressortir au point d’écoulement du liquide sur la machine. Nous faisons donc le choix de sacrifier de la longueur de file dans le fond de certaines bouteilles. Semaine 30 Janvier : Plusieurs étapes du projet sont réalisées cette semaine, nous travaillons à la fois sur la finalisation de notre code et de notre montage pour quatre pompes et quatre boutons, mais aussi sur la construction de la structure et sur le site que nous avons souhaité réaliser afin de présenter nos boissons. Réalisation du site : Pour finaliser le projet il nous a fallu trouver la meilleure interface afin de rendre le distributeur ergonomique et facile d’utilisation. Nous avons donc décidé de commencer une maquette. Comme il était complexe de faire un design directement sur la machine nous avons pensé faire un menu virtuel.  Nous sommes tout d’abord partis sur une carte virtuelle avec le menu lié à un QR Code sur la machine. Après réflexions nous avons décidé de voir encore plus loin en créant un site permettant d’avoir accès aux menus.  Le site s’appelle Flamme & Co, un nom qui nous embarque dans une ambiance chaleureuse avec « Flamme » et rafraichissante avec « Co » (pour coktail), et qui nous fait voyager : Flamenco (Flamme & Co). Le site est composé de l’accueil où l’on peut trouver les différentes informations clés sur la marque. D’autre part dans l’onglet « Commandes en ligne » on peut retrouver et choisir les différentes boissons proposées. Pour rendre accessible le site, nous avons souhaité installer un QR code sur notre machine afin d'y avoir directement accès et pouvoir découvrir le détails des boissons proposées. Code et montage : Le montage et le code ayant été réalisé pour une pompe liée à un bouton et au capteur, la suite était donc d'appliquer tout cela à quatre pompes et quatre boutons afin d'avoir deux cocktails et deux boissons à proposer. En suivant le même montage que celui pour une pompe et un bouton, nous avons donc réussi à le reproduire avec nos trois pompes et boutons supplémentaires. Le code suivant nous permet d'activer nos quatre pompes avec quatre boutons. const int pingPin = 10; const int pumpPin2 = 2; // // le relais est connecté à la broche  de la carte Adruino const int pumpPin3 = 3; // // le relais est connecté à la broche  de la carte Adruino const int pumpPin4 = 4; // // le relais est connecté à la broche  de la carte Adruino const int pumpPin5 = 5; // // le relais est connecté à la broche  de la carte Adruino const int bouton1 = 6; const int bouton2 = 7; const int bouton3 = 8; const int bouton4 = 9; boolean boutonappuye1; boolean boutonappuye2; boolean boutonappuye3; boolean boutonappuye4; boolean proche; void setup() { // initialize serial communication: Serial.begin(9600); // The PING))) is triggered by a HIGH pulse of 2 or more microseconds. // Give a short LOW pulse beforehand to ensure a clean HIGH pulse: pinMode(pumpPin2, OUTPUT); pinMode(pumpPin3, OUTPUT); pinMode(pumpPin4, OUTPUT); pinMode(pumpPin5, OUTPUT); ; pinMode(bouton1,INPUT); pinMode(bouton2,INPUT); pinMode(bouton3,INPUT); pinMode(bouton4,INPUT); } void loop() { // establish variables for duration of the ping, and the distance result // in inches and centimeters: long duration, inches, cm; // The same pin is used to read the signal from the PING))): a HIGH pulse // whose duration is the time (in microseconds) from the sending of the ping // to the reception of its echo off of an object. pinMode(pingPin, OUTPUT); digitalWrite(pingPin, LOW); delayMicroseconds(2); digitalWrite(pingPin, HIGH); delayMicroseconds(5); digitalWrite(pingPin, LOW); pinMode(pingPin, INPUT); duration = pulseIn(pingPin, HIGH); // convert the time into a distance inches = microsecondsToInches(duration); cm = microsecondsToCentimeters(duration); Serial.print(cm); Serial.print("cm"); Serial.println(); boutonappuye1 = digitalRead(bouton1); Serial.println(boutonappuye1); boutonappuye2 = digitalRead(bouton2); Serial.println(boutonappuye2); boutonappuye3 = digitalRead(bouton3); Serial.println(boutonappuye3); boutonappuye4 = digitalRead(bouton4); Serial.println(boutonappuye4); proche = (cm<5); if (boutonappuye1 && proche) { digitalWrite(pumpPin2, LOW);// la pompe à eau remplit la bouteille digitalWrite(pumpPin3, LOW);// la pompe à eau remplit la bouteille delay(5000); digitalWrite(pumpPin2, HIGH); // la pompe à eau s'arrête digitalWrite(pumpPin3, HIGH);// la pompe à eau s'arrête } else { digitalWrite(pumpPin2, HIGH); // la pompe à eau s'arrête digitalWrite(pumpPin3, HIGH);// la pompe à eau s'arrête } if (boutonappuye2 && proche) { digitalWrite(pumpPin5, LOW);// la pompe à eau remplit la bouteille delay(5000); } else { digitalWrite(pumpPin5, HIGH);// la pompe à eau s'arrête } if (boutonappuye3 && proche){ digitalWrite(pumpPin4, LOW);// la pompe à eau remplit la bouteille delay(5000); digitalWrite(pumpPin4, HIGH);// la pompe à eau s'arrête } else { digitalWrite(pumpPin4, HIGH); // la pompe à eau s'arrête } if (boutonappuye4 && proche) { digitalWrite(pumpPin2, LOW);// la pompe à eau remplit la bouteille delay(5000); digitalWrite(pumpPin2, HIGH);// la pompe à eau s'arrête } else { digitalWrite(pumpPin2, HIGH); // la pompe à eau s'arrête } } long microsecondsToInches(long microseconds) { // According to Parallax's datasheet for the PING))), there are 73.746 // microseconds per inch (i.e. sound travels at 1130 feet per second). // This gives the distance travelled by the ping, outbound and return, // so we divide by 2 to get the distance of the obstacle. // See: https://www.parallax.com/package/ping-ultrasonic-distance-sensor-downloads/ return microseconds / 74 / 2; } long microsecondsToCentimeters(long microseconds) { // The speed of sound is 340 m/s or 29 microseconds per centimeter. return microseconds / 29 / 2; } Nous nous sommes rendus compte lorsque nous avons voulu faire fonctionner notre montage avec les quatre pompes que la pompe 4 ne fonctionnait pas. Nous l'avons testée toute seule et elle ne fonctionnait toujours pas. En essayant de la changer avec une des trois autres pompes qui nous restait nous avions toujours le même problème et sommes resté assez longtemps bloqué dessus. Au final en essayant de refaire deux montages séparés avec deux pompes sur des platines différentes puis de les assembler ensemble sur une seule platine et un seule arduino, nous avons fini par avoir un montage fonctionnel associé à un code fonctionnel. En parallèle, nous travaillons sur le montage de la structure : Prise de mesures réelles et découpes des 1er planches. Nous cherchons le materiel le plus adapté pour crée le cadre de notre machine. Nous avons choisi du bois car léger et facile d’accès et facilement découpable et donc assemblable. Nous avons opté pour du bois de 7mm afin d’assurer l’intégrité de la machine. Plusieurs options : rails, clous, colle, découpage pour entrelacement du bois, vis… Peu de vis avaient une taille adapté à notre taille de bois, en effet soit elles étaient au bon diamètre mais trop longues, soit à la bonne longueur mais beaucoup trop large. (suite...) Nous travaillons donc avec la découpeuse laser pour les découpes concernant le bac de récupération, les planches de la structure (pour les façonner à la bonne taille et faire les trous nécessaires pour faire passer nos éléments comme les tuyaux reliés aux pompes par exemple). La machine à gravure est aussi utilisée pour notre le QR code amenant à notre site, mais aussi pour la plaquette comportant le nom de notre groupe et nos noms. Nous nous sommes énormément aidé de la découpeuse laser pour couper nos planches. Nous avons utilisé 7 planches principales ; -3 planches de 22,5 x 50 cm, une en arrière qui peut s’ouvrir, les deux autres sur les côtés. -1 planche de 22,5 x 45,4 cm, pour placer notre équipement, pompes, arduino, breadboard. -2 planches de 22,5 x 30 cm, une pour placer nos bouteilles et l’autre pour placer notre capteur sonore. -1 planche de 22,5 x 13,1 cm, pour placer la carte électronique. Nous avons également découpé des trous pour faire passer nos tuyaux en travers, 4 trous ont été fait et chacun d’eux a un diamètre de 0,9 cm, quant à nos pompes nous avons décidé de les coller directement sur la planche où nous avons placer la breadboard et l’arduino. Un cinquième trou de 1,8 cm de diamètre a été conçu pour que nous puissions réunir tous nos tuyaux Semaine du 6 Février : Pour réaliser notre machine, nous avons décidé de partir sur 4 boissons différentes : eau, jus de pomme, Coca et Whisky. Nous avons donc utilisé 4 pompes différentes et 4 boutons poussoirs. Notre but était d’avoir au moins un mélange parmi les différentes boissons, nous avons donc opté pour un mélange whisky coca qui est contrôlé par un seul bouton quant aux trois autres boutons eux vont permettre de donner les boissons sans mélange ; eau, jus de pomme, Coca. Concernant le code, comme nous avions besoin d'un capteur déclenchant une action nous avions donc fait en sorte de mettre en place deux conditions pour que notre machine fonctionne. Appuyer sur le bouton est obligatoire pour utiliser la machine mais aussi cette condition doit être accompagnée par une autre condition qui est d'être à une distance bien spécifique du capteur sonar pour que le gobelet se remplisse. Si les deux conditions ne sont pas respectées alors rien ne s’écoule des tuyaux. Pour une question de simplicité d’accès et d’esthétique nous avons soudé les boutons poussoirs sur une carte électronique (circuit imprimé). Il nous faut ensuite y souder des fils de connexions qui pourront ensuite être reliés à la platine. Attention à être attentif aux placements des fils en comparant l'endroit et l'envers. En effet, en suivant le montage initial, nous savons que le fil GND est en haut à droite, le fil 5V est en haut à gauche et le fil pour le pin digital est à en bas à droite. Donc pour souder correctement en gardant ces emplacements, ils nous faut souder notre fil noir (GND) en haut à gauche, le fil blanc (5V) en haut à droite et le fil bleu (digital) en bas à gauche. Comme montré dans la photo ci-dessous : Nous pouvons ensuite relier les fils à la platine. Il est donc possible de voir l'agencement de nos pompes et de leurs tuyaux dans notre machine. Les bouteilles se trouvant en dessous de la planche. (photo ?). Jeudi 9 Février : Le jour de la présentation, les dernières retouches sont faites ; le montage du bac d’écoulement, les dernières planches sont mises en place. Nous effectuons nos gravures pour le QR code et celle de présentation du projet. Nous avons rencontré un problème avant la présentation, la breadboard a cessé de fonctionner, nous étions obligés de refaire les branchements, deux des pompes utilisées n’étaient pas assez puissante, le tuyau utilisé avait une longueur de 1 m ce qui n’était pas assez long (par exemple nous n’avons pas pu faire rentrer complètement nos tuyaux dans les bouteilles ; conséquence très peu de liquide sortait du tuyau.) Nous devons aussi adapter le code au vu de la puissance des pompes. Nous rappelons que les pompes 2 et 3 ne sont pas assez puissante pour pomper n'importe quel liquide. Et nous devons nous rattraper uniquement en utilisant les pompes 4 et 5 correspondant respectivement au whisky et au jus de pomme. const int pingPin = 10; const int pumpPin2 = 2; // // le relais est connecté à la broche de la carte Adruino const int pumpPin3 = 3; // // le relais est connecté à la broche de la carte Adruino const int pumpPin4 = 4; // // le relais est connecté à la broche de la carte Adruino const int pumpPin5 = 5; // // le relais est connecté à la broche de la carte Adruino const int bouton1 = 6; const int bouton2 = 7; const int bouton3 = 8; const int bouton4 = 9; boolean boutonappuye1; boolean boutonappuye2; boolean boutonappuye3; boolean boutonappuye4; boolean proche; void setup() { // initialize serial communication: Serial.begin(9600); // The PING))) is triggered by a HIGH pulse of 2 or more microseconds. // Give a short LOW pulse beforehand to ensure a clean HIGH pulse: pinMode(pumpPin2, OUTPUT); pinMode(pumpPin3, OUTPUT); pinMode(pumpPin4, OUTPUT); pinMode(pumpPin5, OUTPUT); ; pinMode(bouton1,INPUT); pinMode(bouton2,INPUT); pinMode(bouton3,INPUT); pinMode(bouton4,INPUT); } void loop() { // establish variables for duration of the ping, and the distance result // in inches and centimeters: long duration, inches, cm; // The same pin is used to read the signal from the PING))): a HIGH pulse // whose duration is the time (in microseconds) from the sending of the ping // to the reception of its echo off of an object. pinMode(pingPin, OUTPUT); digitalWrite(pingPin, LOW); delayMicroseconds(2); digitalWrite(pingPin, HIGH); delayMicroseconds(5); digitalWrite(pingPin, LOW); pinMode(pingPin, INPUT); duration = pulseIn(pingPin, HIGH); // convert the time into a distance inches = microsecondsToInches(duration); cm = microsecondsToCentimeters(duration); Serial.print(cm); Serial.print("cm"); Serial.println(); boutonappuye1 = digitalRead(bouton1); Serial.println(boutonappuye1); boutonappuye2 = digitalRead(bouton2); Serial.println(boutonappuye2); boutonappuye3 = digitalRead(bouton3); Serial.println(boutonappuye3); boutonappuye4 = digitalRead(bouton4); Serial.println(boutonappuye4); proche = (cm<3); digitalWrite(pumpPin2, HIGH); digitalWrite(pumpPin3, HIGH); digitalWrite(pumpPin4, HIGH); digitalWrite(pumpPin5, HIGH); if (boutonappuye1 && proche) { digitalWrite(pumpPin4, LOW);// la pompe à whisky remplit le verre delay(10000); digitalWrite(pumpPin4, HIGH);// la pompe à whisky s'arrête digitalWrite(pumpPin2, LOW);// la pompe à coca remplit le verre delay(40000); digitalWrite(pumpPin2, HIGH);// la pompe à coca s'arrête } else { digitalWrite(pumpPin4, HIGH); // la pompe à eau s'arrête digitalWrite(pumpPin2, HIGH);// la pompe à eau s'arrête } if (boutonappuye2 && proche) { digitalWrite(pumpPin5, LOW);// la pompe à jus de pomme est amené au verre delay(60000); digitalWrite(pumpPin5, HIGH); } else { digitalWrite(pumpPin5, HIGH);// la pompe s'arrête } if (boutonappuye3 && proche){ digitalWrite(pumpPin3, LOW);// la pompe à eau remplit le verre delay(10000); digitalWrite(pumpPin3, HIGH);// la pompe à eau s'arrête } else { digitalWrite(pumpPin3, HIGH); // la pompe à eau s'arrête } if (boutonappuye4 && proche) { digitalWrite(pumpPin2, LOW);// la pompe à coca remplit le verre delay(5000); digitalWrite(pumpPin2, HIGH);// la pompe à coca s'arrête } else { digitalWrite(pumpPin2, HIGH); // la pompe à coca s'arrête } } long microsecondsToInches(long microseconds) { // According to Parallax's datasheet for the PING))), there are 73.746 // microseconds per inch (i.e. sound travels at 1130 feet per second). // This gives the distance travelled by the ping, outbound and return, // so we divide by 2 to get the distance of the obstacle. // See: https://www.parallax.com/package/ping-ultrasonic-distance-sensor-downloads/ return microseconds / 74 / 2; } long microsecondsToCentimeters(long microseconds) { // The speed of sound is 340 m/s or 29 microseconds per centimeter. return microseconds / 29 / 2; } Il nous faut donc 1 minute d'activité de notre pompe 5 pour pouvoir remplir à moitié notre verre de 33 cl, ce qui corroborent notre hypothèse que les pompes ne sont pas assez performantes. Mardi 14 février : Nous sommes revenus ce mardi pour apporter quelques finitions au projet. Il fallait notamment refermer la structure avec la planche du haut pour pouvoir cacher les branchements.  Elle avait été découpé un peu plus grande que prévue, nous avons donc du la repasser à la découpeuse laser pour enlever 1 mm dans la largeur et 5 mm dans la longueur. Au vu des problèmes de pompes, nous avions comme objectif de changer les pompes 2 et 3 qui ne fonctionnaient pas assez contre d'autres qui seraient éventuellement assez puissantes. En testant les 3 pompes supplémentaires qui n'étaient pas initialement utilisées, aucunes d'entre elles ne permettaient de pomper du liquide. La décision a été prise de se limiter à deux pompes fonctionnelles et donc deux boutons. Le montage final comporte deux pompes, la pompe 4 relié au coca et la 5 au jus de pomme. Le coca est servi lorsque nous appuyons sur le bouton 1 et le bouton 2 est pour le jus de pomme. En testant à nouveau les pompes, nous avons décidé de changer les temps de "delay", car en effet pour un temps de fonctionnement de 25000 ms ou 25 s, nous avons environ 12,5 cl de boisson versé, ce qui nous a semblé adapté pour différents volume de verre. const int pingPin = 10; const int pumpPin4 = 4; // // le relais est connecté à la broche de la carte Adruino const int pumpPin5 = 5; // // le relais est connecté à la broche de la carte Adruino const int bouton1 = 6; const int bouton2 = 7; boolean boutonappuye1; boolean boutonappuye2; boolean proche; void setup() { // initialize serial communication: Serial.begin(9600); // The PING))) is triggered by a HIGH pulse of 2 or more microseconds. // Give a short LOW pulse beforehand to ensure a clean HIGH pulse: pinMode(pumpPin4, OUTPUT); pinMode(pumpPin5, OUTPUT); ; pinMode(bouton1,INPUT); pinMode(bouton2,INPUT); } void loop() { // establish variables for duration of the ping, and the distance result // in inches and centimeters: long duration, inches, cm; // The same pin is used to read the signal from the PING))): a HIGH pulse // whose duration is the time (in microseconds) from the sending of the ping // to the reception of its echo off of an object. pinMode(pingPin, OUTPUT); digitalWrite(pingPin, LOW); delayMicroseconds(2); digitalWrite(pingPin, HIGH); delayMicroseconds(5); digitalWrite(pingPin, LOW); pinMode(pingPin, INPUT); duration = pulseIn(pingPin, HIGH); // convert the time into a distance inches = microsecondsToInches(duration); cm = microsecondsToCentimeters(duration); Serial.print(cm); Serial.print("cm"); Serial.println(); boutonappuye1 = digitalRead(bouton1); Serial.println(boutonappuye1); boutonappuye2 = digitalRead(bouton2); Serial.println(boutonappuye2); proche = (cm<5); if (boutonappuye1 && proche) { digitalWrite(pumpPin4, LOW);// la pompe à eau remplit la bouteille delay(25000); digitalWrite(pumpPin4, HIGH);// la pompe s'arrête } else { digitalWrite(pumpPin4, HIGH);// la pompe s'arrête } if (boutonappuye2 && proche) { digitalWrite(pumpPin5, LOW);// la pompe à coca remplit la bouteille delay(25000); digitalWrite(pumpPin5, HIGH);// la pompe s'arrête } else { digitalWrite(pumpPin5, HIGH);// la pompe s'arrête } } long microsecondsToInches(long microseconds) { // According to Parallax's datasheet for the PING))), there are 73.746 // microseconds per inch (i.e. sound travels at 1130 feet per second). // This gives the distance travelled by the ping, outbound and return, // so we divide by 2 to get the distance of the obstacle. // See: https://www.parallax.com/package/ping-ultrasonic-distance-sensor-downloads/ return microseconds / 74 / 2; } long microsecondsToCentimeters(long microseconds) { // The speed of sound is 340 m/s or 29 microseconds per centimeter. return microseconds / 29 / 2; } Régulation du taux d'humidité UE 803 - Optimisation et Contrôle des Procédés - Master 2 - Ingénierie Chimique Projet Expérimental Arduino Objectif du projet : Réussir à réguler un flux d'air sec et un flux de d'air humidifié à l'aide d'un barboteur pour réguler le taux d'humidité dans l'air à l'aide de 2 pompes et du logiciel Arduino. Pourquoi avons-nous choisi ce projet ? La régulation de l'humidité de l'air est un procédé très utilisé en industrie pour réaliser des analyses qualitatives mais aussi dans le but de tester la résistance de certains produits à l'humidité notamment en industrie. Liste du matériel : 2 x Électrovannes pour l'air 2 x Tuyaux hermétiques pour le montage qui seront découpés en plusieurs morceaux 1 x Barboteur maison 1 x Capteur d’humidité 2 x Pompes 1 x Carte Arduino 2 x bouteilles 1 x paquet de riz 2 x relais fils électrique pour raccorder les appareils entre eux - Réalisation d'un schéma prototype du montage (28/10/2022) On a réalisé un premier schéma du montage afin d'étudier les équipements dont nous aurions besoin pour réaliser notre projet. - Réalisation du support du projet (12/01/2023) Sur cette première image on peut voir support qui a été assemblé à partir de bois recycler. - Réalisation du barboteur (12/01/2023)                                   Afin de réaliser notre barboteur nous utilisons une bouteille de soda sur laquelle nous réalisons 2 trous : le 1er en bas de la bouteille qui est la sortie d'air humide et le second en haut de la bouteille au niveau du bouchon pour l'entrée gaz sec. Les trous ont été réalisés à l'aide de la perceuse à colonne qui nous permet d'avoir plus de précision pour la réalisation de nos trous. Pour humidifier l'air il entre par le haut de la bouteille dans un tube qui bullera dans l'eau pour l'humidifier. - Réalisations des relais pour le contrôle des pompes (12/01/2023) Des relais ont été ajoutés afin de pouvoir contrôler les pompes individuellement en fonction du signal envoyé par la carte arduino. - Réalisation du montage Arduino / Code (26/01/2023) Code que nous avons trouvé et qui a été testé : */ #include #define brocheDeBranchementDHT 6 // La ligne de communication du DHT22 sera donc branchée sur la pin D6 de l'Arduino #define typeDeDHT DHT22 // Ici, le type de DHT utilisé est un DHT22 (que vous pouvez changer en DHT11, DHT21, ou autre, le cas échéant) // Instanciation de la librairie DHT DHT dht(brocheDeBranchementDHT, typeDeDHT); // ======================== // Initialisation programme // ======================== void setup () { // Initialisation de la liaison série (pour retourner les infos au moniteur série de l'ordi) Serial.begin(9600); Serial.println("Programme de test du DHT22"); Serial.println("=========================="); Serial.println(); // Initialisation du DHT22; dht.begin(); } // ================= // Boucle principale // ================= void loop () { // Lecture des données float tauxHumidite = dht.readHumidity(); // Lecture du taux d'humidité (en %) float temperatureEnCelsius = dht.readTemperature(); // Lecture de la température, exprimée en degrés Celsius // Vérification si données bien reçues if (isnan(tauxHumidite) || isnan(temperatureEnCelsius)) { Serial.println("Aucune valeur retournée par le DHT22. Est-il bien branché ?"); delay(2000); return; // Si aucune valeur n'a été reçue par l'Arduino, on attend 2 secondes, puis on redémarre la fonction loop() } // Calcul de la température ressentie float temperatureRessentieEnCelsius = dht.computeHeatIndex(temperatureEnCelsius, tauxHumidite, false); // Le "false" est là pour dire qu'on travaille en °C, et non en °F // Affichage des valeurs Serial.print("Humidité = "); Serial.print(tauxHumidite); Serial.println(" %"); Serial.print("Température = "); Serial.print(temperatureEnCelsius); Serial.println(" °C"); Serial.print("Température ressentie = "); Serial.print(temperatureRessentieEnCelsius); Serial.println(" °C"); Serial.println(); // Temporisation de 2 secondes (pour rappel : il ne faut pas essayer de faire plus d'1 lecture toutes les 2 secondes, avec le DHT22, selon le fabricant) delay(2000); } On réalise les premiers branchements des 2 pompes sur la carte arduino ainsi que le capteur d'humidité qui nous a d'ailleurs posé un peu problème car le capteur possède 4 branches et nous n'avons la possibilité que de brancher 4 branches nous avons donc demander de l'aide à monsieur Pulpytel pour nous aider pour ce branchement. Suite à ça nous avons recherché le code afin de faire fonctionner le capteur d'humidité et pouvoir récupérer les valeurs. Code que nous avons réalisé : #include #include #include #define brocheDeBranchementDHT 6    // La ligne de communication du DHT22 sera donc branchée sur la pin D6 de l'Arduino#define typeDeDHT DHT22             // Ici, le type de DHT utilisé est un DHT22 (que vous pouvez changer en DHT11, DHT21, ou autre, le cas échéant)// Instanciation de la librairie DHTDHT dht(brocheDeBranchementDHT, typeDeDHT);int objectif;const int relais_pompe1 = 3;const int relais_pompe2 = 4;// ========================// Initialisation programme// ========================void setup () { // Initialisation de la liaison série (pour retourner les infos au moniteur série de l'ordi)  Serial.begin(9600);  Serial.println("Programme de test du DHT22");  Serial.println("==========================");  Serial.println();  pinMode(BROCHE_CAPTEUR, INPUT_PULLUP);  pinMode(relais_pompe1,OUTPUT);  pinMode(relais_pompe2,OUTPUT); // Initialisation du DHT22;  dht.begin();} // =================// Boucle principale// =================void loop () { // Lecture des données  float tauxHumidite = dht.readHumidity();              // Lecture du taux d'humidité (en %)  float temperatureEnCelsius = dht.readTemperature();   // Lecture de la température, exprimée en degrés Celsius printf("quel est le taux d'humidité souhaité ?"); scanf("%d",&objectif);  // Vérification si données bien reçues  if (isnan(tauxHumidite) || isnan(temperatureEnCelsius)) {    Serial.println("Aucune valeur retournée par le DHT22. Est-il bien branché ?");    delay(2000);    return;         // Si aucune valeur n'a été reçue par l'Arduino, on attend 2 secondes, puis on redémarre la fonction loop()  }  // Calcul de la température ressentie  float temperatureRessentieEnCelsius = dht.computeHeatIndex(temperatureEnCelsius, tauxHumidite, false); // Le "false" est là pour dire qu'on travaille en °C, et non en °F // Affichage des valeurs  Serial.print("Humidité = "); Serial.print(tauxHumidite); Serial.println(" %");  Serial.print("Température = "); Serial.print(temperatureEnCelsius); Serial.println(" °C");  Serial.print("Température ressentie = "); Serial.print(temperatureRessentieEnCelsius); Serial.println(" °C");  Serial.println();  // Temporisation de 2 secondes (pour rappel : il ne faut pas essayer de faire plus d'1 lecture toutes les 2 secondes, avec le DHT22, selon le fabricant)  delay(2000);  while(tauxHumidite!=objectif){if(tauxHumidite