DistributeurBoisson

Prérequis

LE DISTRIBUTEUR DE BOISSON Bvm972

INTRODUCTION

Dans le cadre de notre de notre projet de fin d'études au sein du département GEII de l'IUT de Troyes, nous avons eu à remettre en état de marche un distributeur de boisson à partir de la deuxième moitié du troisième semestre.
Le but de ce projet de fin d'études est de mettre en application tous nos acquis.

Cahier de charges

Le cahier des charges sert à définir les différents objectifs clés au début du processus de réalisation du projet.
Dans notre cas, il s'agissait de :
-Concevoir et fabriquer une carte électronique permettant d'observer l'état des capteurs et activer les actionneurs.
-Ainsi que réaliser un circuit hydraulique fonctionnel permettant d'envisager de pouvoir servir du café puis différentes boissons d'ici la fin du S4.

Etude & Réalisation

PILOTAGE DES CAPTEURS

Ce capteur que nous avons utilisé est un capteur TOR, une sorte d’interrupteur qui informe d’un stock plein de l’eau lorsque le courant passe.

Schéma Electronique

Ce schéma électronique nous a permis de faire des testes sur une plaque à essais.
Ceci nous a permis de piloter les capteurs en simulation et ensuite le remplacer par les capteurs qui sont dans le distributeur de boisson.
Ensuite en le programme en suivant l'algorithme ci dessous:
Lorsque la led est à l'etat 1 c'est à dire qu'il y a de l'eau dans la cuve.
Lorsqu'elle est à l'etat bas led=0 c'est à dire qu'il n'y a pas de l'eau dans la cuve.

Microship

Le MCP23017 utilise 2 broches I2C pins (qui peuvent être partagées avec d'autres périphériques I2C), et en échange, il fournit 16 broches d'utilisation générale en plus.
Chacune des 16 broches peut être configurée:

en entrée (input)
en sortie (output)

Alimentation

Attention de ne pas inverser le sens de raccordement.

VDD: Alimentation
VSS: GND, la masse

Les entrées/Sorties

Notées GPAx et GPBx. Toutes les entrées/sorties GPAx sont codées sur un octet (byte) tandis que toutes les entrées/sorties GPBx sont codées sur un autre octets.

Si vous utilisez moins de 8 entrées/sorties, il est préférable de les regrouper sur GPAx... car du coup, elles peuvent toutes être commandées en même temps avec un seul octet.

Brancher le bus I2C

Connectez la broche #12 sur Arduino broche Analogique A5 (Horloge I2C, SCL)
Connectez la broche #13 sur Arduino broche Analogique A4 (Données I2C, SDA)
Ce circuit intégré peut être utilisé entre 2.7 et 5.5V (convient donc pour tous du 3.3V comme Raspberry Pi ou 5V comme Arduino).
Vous pouvez consommer jusqu'à 20mA sur n'importe quelle porte... vous pouvez donc allumer une LED.

Changement d'adresse

Les circuits intégrés se trouvant sur un Bus I2C ont chacun une adresse (un peut comme un numéro de maison dans une rue).
Cela permet de connecter plusieurs circuit sur un même bus (les même fils SDA et SCL) et de pouvoir s'adresser à un circuit bien particulier en utilisant sont adresse.
Il ne peut pas y avoir deux circuits différents avec la même adresse sur le Bus. Il est possible de combiner différent types de circuits I2C sur un même bus... chaque circuit ayant sa propre adresse différente des autres circuits (ce qui est généralement le cas). Si l'on veut mettre plusieurs fois le même circuit sur un bus I2C alors il faut pourvoir en changer l'adresse.

L’adresse du MCP23017 est constituée de 4 bits imposés (0100), 3 bits utilisateurs. Les trois bits d’adresse utilisateur correspondent aux broches 15 à 17 (des broches A0, A1, A2) d’un MCP23017, qui doivent êtres toutes connectées. Dans le tableau suivant, ceux indiqués à 1 sont reliés à l’alimentation (3V3), et ceux indiqués à 0 sont reliés à la masse (GND).

Librairie

"Adafruit MCP23017 Arduino Library" «GitHub d'AdaFruit»
"Adafruit MCP23008 Arduino Library" «GitHub d'AdaFruit»

Schématique & Routage

Voici quelques contraintes de routage que nous avons respecter :
- pistes : 0,4 mm mini
- écartement entre les pistes : 0,4 mm mini
- Via : 0.8 pour les trous et 1,25 pour le diamètre externe

Carte Capteur

Test effectué:
-Vérification de la communication avec le MCP23017 (I2C SCANNER).
-Communication avec les capteur du distributeur.

Code de pilotage de capteurs

Ce code nous a permit de piloter les capteurs, dont à savoir les différents nivaux( 0 ou 1 ) c'est dont un capteur Tout Ou Rien.
Niveau Bas(0): Absence d'eau dans la cuve.
Niveau Haut(1): Présence d'eau dans la cuve.

code de pilotage de capteurs

#include <Wire.h>
#include <Adafruit_MCP23017.h>
Adafruit_MCP23017 mcp;

int bouton = 9;     // Numéro de la broche à laquelle est connecté le bouton poussoir
int led =  8;      // Numéro de la broche à laquelle est connectée la LED

// Déclaration des variables :
int etatBouton = 0;         // variable qui sera utilisée pour stocker l'état du bouton

  
void setup() {  
  Serial.begin(9600);
  mcp.begin();      // use default address 0
  mcp.pinMode(led, OUTPUT);     // indique que la broche led est une sortie :
  mcp.pinMode(bouton, INPUT);  // indique que la broche bouton est une entrée :
}

           // le code dans cette fonction est exécuté en boucle
void loop() {
  etatBouton = mcp.digitalRead(bouton);   // lit l'état du bouton et stocke le résultat dans etatBouton

         // Si etatBouton est à 5V (HIGH) c'est que le bouton est appuyé
  if ( etatBouton == HIGH) {     
     mcp.digitalWrite(led, HIGH);  // on allume la LED(presence d'eau dans la cuve au nivau max.)
      Serial.println(0);          //On affiche l'etat de la led sur le moniteur serie
      delay(1000);               //Pour une durée de 1s(Petite temporisation)
  
  }
  else {
     mcp.digitalWrite(led, LOW); // sinon on éteint(Absence d'eau dans la cuve)
      Serial.println(1);         //On affiche l'etat de la led sur le moniteur serie
      delay(1000);              //Pour une durée de 1s(Petite temporisation)
  }
}

PILOTAGE DES ACTIONNEURS

Composants

Dans un premier temps, nous allons présenté les différents "composants" utilisés pour commander les différents actionneurs (électrovannes ou moteurs par exemple) :
-MCP23008: c’est un circuit intégré sur lequel on a la possibilité de brancher ou connecter plusieurs composants (Actionneurs et pré actionneurs).
-Diode de roue libre: placer en inverse et en parallèle avec la charge permet de réguler la tension dans un circuit sous une source de tension variable.
-le Transistor: permet de contrôler le passage du courant dans le circuit entre le Drain et la Source.
-le Con-faston: est une sorte de bornier qui permet de relier les actionneurs à la carte électronique à travers des conducteurs (fils électriques).
-le Con-lstb: sont reliés au PIN (A0, A1 et A2: qui permet de changer la valeur de l’adresse) du MCP23008 qui vont nous permettre de faire le choix entre (0V et 5v).
-la Résistance: qui permet de limiter le courant dans le circuit.

Schéma fonctionnel

Code final de la partie hydraulique

Avant toute chose, il est nécessaire de rappeler qu'il faut télécharger la librairie adafruit/Adafruit-MCP23008 et Adafruit-MCP23017-Arduino-Library - GitHub en format zip, ensuite l'inclure dans l'Arduino ( ouvrir Arduino ensuite clic sur [Croquis + Inclure une bibliothèque] enfin clic sur ajouter la bibliothèque zip).
C'est l'étape la plus importante car Arduino n'a pas ces librairies et ensuite déclarer les variables, donner les instructions en fonction de notre besoin.

Pour les télécharger:
"Adafruit MCP23017 Arduino Library" «GitHub d'AdaFruit»
"Adafruit MCP23008 Arduino Library" «GitHub d'AdaFruit»

voir code

 
#include <Wire.h>
#include "Adafruit_MCP23008.h"
#include "Adafruit_MCP23017.h"

Adafruit_MCP23008 mcp_sortie; //que les electrovannes sur ce mcp
Adafruit_MCP23017 mcp_entree;


int pinBouton  = 11;
int pinBouton2 = 13; //bouton et bouton2 correspondent aux deux capteurs
int pinGrille1 = 7;
int pinGrille2 = 6;
bool conditiondepart = 0;
int pinLed1    = 10;
int pinBoutonPoussoir = 8;
int pinBoutonPoussoir2 = 9;
int pinLed2    = 50;//12
void setup()
{
   mcp_entree.begin(2);
  mcp_sortie.begin();// utiliser l'adresse par défaut
  // définition des broches en sortie
  //Serial.begin(9600);
  mcp_entree.pinMode(pinBouton,  INPUT);
   mcp_entree.pinMode(pinBoutonPoussoir,  INPUT);
     mcp_entree.pinMode(pinBoutonPoussoir2,  INPUT);
  mcp_sortie.pinMode(pinGrille1, OUTPUT);
  mcp_sortie.pinMode(pinGrille2, OUTPUT);
  mcp_entree.pinMode(pinLed1,    OUTPUT);
   mcp_entree.pinMode(pinLed2,    OUTPUT);
 pinMode(1,OUTPUT);//pompe
}
void loop()
{
  
    
    if (mcp_entree.digitalRead(pinBoutonPoussoir)==HIGH){
   conditiondepart = !conditiondepart;
   delay(400);
    }
   
   if (conditiondepart == 1)
   {
   if (mcp_entree.digitalRead(pinBouton)==HIGH) //attention c'est l'inverse de la position du flotteur
  {
    mcp_sortie.digitalWrite(pinGrille1,HIGH); //5v
    mcp_sortie.digitalWrite(pinGrille2,LOW);
     mcp_entree.digitalWrite(pinLed1, LOW); 
    digitalWrite(1,LOW); //pompe
    }
    else
    {
   mcp_sortie.digitalWrite(pinGrille1,LOW);
   mcp_sortie.digitalWrite(pinGrille2,HIGH); //
  mcp_entree.digitalWrite(pinLed1,HIGH); //
  digitalWrite(1, HIGH);//pompe
      }
  delay(100); //petite attente
   }
   else if (conditiondepart ==0){
    mcp_entree.digitalWrite(pinLed1, LOW);
     digitalWrite(1,LOW);
  }
   delay(1);
   
   }

CONCLUSION

Pendant ce projet, nous avons eu l'opportunité de s'entraîner sur les logiciels tels que Eagle et arduino et aussi de développer les compétences en matière de fabrication et de programmation de cartes avec des MCP. Nous avons écrit les programmes en C pour tester le fonctionnement de la carte fabriquée. C’est un projet très intéressant et très enrichissant. Pour nous, il a fallu faire preuve d'ingéniosité pour trouver les raisons des dysfonctionnement pendant les tests et également pour souder des composants à la place de certains qui ont été abîmés pendant les essais. Malgré les problèmes rencontrés nous avons pu trouver des solutions pour que la carte se réalise. Malheureusement nous ne sommes pas allés jusqu'à la fin de notre objectif qui était de faire du café.