LEI400

Distributeur de boisson Bianchi LEI400.

Présentation du projet:

Dans le cadre de notre projet d'étude et réalisation du troisième semestre nous somme chargés de réparer et convertir une machine à café industrielle pour un usage personnel.

• Les paramètres doivent donc tous pouvoir être modifiés par l'utilisateur.
• La machine doit pouvoir s'adapter à la boisson que l'utilisateur veut obtenir (modification du contenu des bacs).
• La machine doit pouvoir s'adapter aux récipients de l'utilisateur.
• La sécurité de l'utilisateur vis-à-vis de la machine.
• Le système de monnaie sera supprimé.

Présentation du distributeur:

La machine:

La machine à café LEI400 sur laquelle nous allons travailler ne fonctionne actuellement plus. Il nous faut donc recréer une carte de puissance et une carte de gestion. A l'origine la machine dispose de 11 boutons permettant de choisir les boissons, et de deux boutons permettant de régler la quantité de sucre.

Documentation:

DOC 1
DOC 2, Utilisateur
DOC 3, Technique

Etude de la machine:

Etude des capteurs:

Flotteur dans la cuvette[3] (voir lei400.pdf p56):

Après avoir testé le contact on s'est rendu compte qu'il est normalement fermé. Sur le connecteur les deux premières broches accessibles sont utilisées.

Capteur de Température

Celui-ci est une thermistance, nous faisons actuellement plusieurs mesures pour obtenir la courbe (et donc l'équation de température) la plus précise. Nous sommes actuellement en train de faire la dernière mesure de la résistance en fonction de la température.

Le programme Arduino est le suivant:

#define resistanceserie 9844.0    
#define pinthermistance A0 
 
void setup(void) {
  Serial.begin(9600);
}
 
void loop(void) {
  float vRt;
  float lecture;
  float RT;
  float Temp;
  lecture = analogRead(pinthermistance);
  vRt = (5.0*lecture)/1023.0;
  RT=(vRt*resistanceserie)/(5.0-vRt);
  //Temp=80.3944*exp(-0.0139854326*(RT/1000));
  //Temp=296.70771*exp(-0.044304*(RT/1000));
  Temp=100.7692461863*exp(-0.0196531819*(RT/1000));
  Serial.println(Temp);
  Serial.println(RT);
  Serial.print("tension au borne de RT : "); 
  Serial.println(vRt);
  delay(1000);
}

Celui-ci nous donnera la température, les lignes en commentaire montre que l'équation de température n'est pas encore stabilisée.

10/11/2016

Un dernière mesure nous a permis de trouver une courbe correct et de sortir une équation polynomiale de degré 3 (pour plus de précision) qui sera instauré dans le programme. Voici la courbe :

on constate la courbe de température entre 32°C et 60°C et son équation de température.

Le nouveau programme arduino est :

#define resistanceserie 9996.0    
#define pinthermistance A0 
 
void setup(void) {
  Serial.begin(9600);
}
 
void loop(void) {
  float vRt;
  float lecture;
  float RT;
  float Temp;
  lecture = analogRead(pinthermistance);
  vRt = ((5.0*lecture)/1023.0);
  RT=(vRt*resistanceserie)/(5.0-vRt);
  RT=RT/1000.0;
  Temp=-0.00011*(RT*RT*RT)+0.02328*(RT*RT)-1.9293904851*RT+92.807;
  Serial.println(Temp);
  Serial.print("tension au borne de RT : ");
  Serial.println(vRt);
  Serial.println(RT);
  delay(800);
}

On voit très bien que l'équation trouvée grâce à la courbe est désormais celle qui va nous indiquer la température.

Montage arduino :

On perçoit la résistance de 10kOhm montée en série avec la thermistance. Les fils noir et rouge que nous voyons sur l'image correspondent à la thermistance.

17/11/2016

Le but de cette sceance est de faire un programme qui permet de réguler la température à 40°C. Pour cela nous allons commander le triac de la résistance chauffante. Notre premier programme consiste à couper le triac lorsque la température atteint 40°C. Le voici :

#define resistanceserie 9996.0    
#define pinthermistance A0 
 
void setup(void) {
  pinMode(8,OUTPUT);
  Serial.begin(9600);
}
 
void loop(void) {
  float vRt;
  float lecture;
  float RT;
  float Temp;
  lecture = analogRead(pinthermistance);
  vRt = ((5.0*lecture)/1023.0)+0.02;
  RT=(vRt*resistanceserie)/(5.0-vRt);
  RT=RT/1000.0;
  Temp=-0.00011*(RT*RT*RT)+0.02328*(RT*RT)-1.9293904851*RT+92.807;
  Serial.print("temperature de l'eau : ");
  Serial.println(Temp);
  Serial.print("tension au borne de RT : ");
  Serial.println(vRt);
  Serial.print("valeur de la thermistance : ");
  Serial.println(RT);
  Serial.println("");
  Serial.println("NOUVELLE MESURE MAGGLE");
delay(500);
  if (Temp>=40)
  {
    digitalWrite (8,HIGH);
  }
  else
  {
    digitalWrite (8,LOW);
  }
}

Dans ce programme, le Triac est remplacé par une led qui s'allume lorsque l'on doit couper le triac !

Pour la suite, on voudrait réguler la température plus précisément, c'est à dire que plus l'on approche de 40°C, moins la puissance dans la résistance chauffante sera élevée. Pour cela, nous allons commander le temps d'ouverture et de fermeture du Triac sur chaque période. Par exemple, si on veut diviser par deux la puissance de la résistance chauffante, on va commander la fermeture du Triac pendant 500ms.

Fin de séance :

Suite à cette séance, on a terminé le programme de régulation de la thermistance. Le principe sera : l'utilisateur donne une consigne de température "je veux mon café à 60°C", le programme mesurera la température de l'eau et calculera le Delta Température entre la consigne et l'eau. En fonction de la valeur du Delta, le Triac sera fermé plus ou moins longtemps.

Voici le programme Arduino :

#define resistanceserie 9996.0    
#define pinthermistance A0 

void setup(void) {
  pinMode(8,OUTPUT);
  Serial.begin(115200);
}

void loop(void) {
  float vRt;
  float lecture;
  float RT;
  float Temp;
  float consigne=50;
  float DeltaT;
  
    while (consigne != 0 && Temp<=consigne)
  {
  lecture = analogRead(pinthermistance);
    vRt = ((5.0*lecture)/1023.0)+0.02;
    RT=(vRt*resistanceserie)/(5.0-vRt);
    RT=RT/1000.0;
    Temp=-0.00011*(RT*RT*RT)+0.02328*(RT*RT)-1.9293904851*RT+92.807;
    DeltaT = consigne-Temp;


    if (DeltaT>30 && DeltaT<=100)
    {
      digitalWrite (8,HIGH);
      delay (100);
    }
    if (DeltaT>=20 && DeltaT<=30)
    {
      digitalWrite (8,HIGH);
      delay (80);
      digitalWrite(8,LOW);
      delay(20);
    }
    if (DeltaT>=10 && DeltaT<=20)
    {
      digitalWrite (8,HIGH);
      delay (60);
      digitalWrite(8,LOW);
      delay(40);
    }
    if (DeltaT>=5 && DeltaT<=10)
    {
      digitalWrite (8,HIGH);
      delay (40);
      digitalWrite(8,LOW);
      delay(60);
    }
    if (DeltaT>=0  &&  DeltaT<=5)
    {
      digitalWrite (8,HIGH);
      delay (20);
      digitalWrite(8,LOW);
      delay(80);
    }
  }
}

Ce programme est testé et fonctionne.

Etude des electrovannes:

Electrovanne d'arrivée d'eau

• 24VDC, 400mA
• Normalement Fermée
• Dispose d'une sécurité mécanique bloquant l'arrivée d'eau si un retour ce produit.

Etude du triac fonctionnant sur le réseau 230V:

Montage réalisé

Lors de la première séance, on a étudié le fonctionnement du triac et on est arrivé à ce montage

Calcul de la résistance d'entrée: R= (5-1,25)/0,015 = 250 ohms. On a pris une tension d'entrée qui vaut 5v (soit celle d'une carte arduino) et l'intensité vaut 15mA max (ceci a été défini par le constructeur, voir datasheet du moc3041).

Valeurs des composants utilisés:

• R1= 220 ohms
• R2= 390 ohms
• R3= 330 ohms
• R4= 39 ohms
• C1= 0,01 uf
• R6= Réstance chauffante

Lors de la deuxième séance, on a préparé la boite pour l'alimentation et on a soudé les différents composants sur une plaquette pour pouvoir tester le bon fonctionnement du système. Pour ne pas faire d'erreurs sur le branchement du triac, on s'est servi de la photo ci-dessous.

Après avoir soudé tous les composants sur la plaquette, on a positionné la plaquette dans la boite et on a soudé les entrées prévus pour l'arduino, pour le secteur, pour la résistance chauffante et pour l'électrovanne. Ce qui nous donne:

On se sert d'un interrupteur qu'on a donc du relier à l'alimentation.

Utilisation du montage

Ce montage va nous permettre de contrôler la pompe à eau principale et la résistance chauffante.

Tests:

Circuit d'arrivée d'eau jusqu'à la cuvette le 06/10

Schéma électrique:

Petit programme arduino:

	boolean flag=true; //on ne veut faire la manip qu'une fois

	void setup() {
	     pinMode(13,OUTPUT);//led carte arduino
             pinMode(2,OUTPUT);
	     pinMode(3,INPUT_PULLUP);//contacteur en pull up on retrouve 0 si pas d'eau et 1 si de l'eau
	}

	void loop() {
	     while(digitalRead(3)==LOW && flag){// si pas plein d'eau et première fois 
		  digitalWrite(13,1);//on rempli
		  digitalWrite(2,1);
	     }
	     flag=false;
	     digitalWrite(13,0);//c'est plein on coupe l'arrivée
	     digitalWrite(2,0);
	}

On constate que l'eau arrive bien jusqu'a la cuvette. Une fois que le flotteur est remonté l'arrivée d'eau est bien coupée par l'arduino.

• Il faut par la suite ajouter une sécurité permettant de couper l'arrivé d'eau si le flotteur monte sans passer par le micro-controleur.

Ébauche d'idées pour la sécurité.

Rappel AND

Entrées		Sorties
A	B	S
0	0	0
0	1	0
1	0	0
1	1	1

On pose A le flotteur dans la cuvette et B le µC.
Quand le niveau de logique de A est 1 on peut ajouter de l'eau.
B doit pouvoir autoriser l'arrivée d'eau si A n'est pas à 0 et il doit pouvoir bloquer l'arrivée d'eau dès qu'il souhaite.

• Pour résumer on doit donc apporter de l'eau seulement quand le niveau le permet et quand le µC le demande on a donc la correspondance avec une fonction AND entre A et B.

Circuit d'arrivée d'eau jusqu'à la cuvette le 20/10

• Ajout du système de sécurité pour bloquer l'arrivée d'eau en cas de cuve pleine.

Dans un premier temps nous avons essayé d'utiliser une porte logique NAND, on constate que le système fonctionne cependant on utilise qu'un quart du composant. Nous allons donc utiliser deux transistors SI2336DS de type N-MOS, qui se contrôlent en tension, en série de façon à ce qu'on ouvre l’électrovanne si et seulement si l'arduino demande l'ouverture et que la cuve n'est pas pleine.

• Cela simplifie le montage et le rend beaucoup plus petit.

Etude du capteur volumétrique le 03/11

• Nous avons étudié le capteur grâce au montage ci dessous et nous avons remarqué qu'à la sortie de ce capteur, on a un signal carré dont la fréquence change en fonction du débit de l'eau.

• Nous avons donc réalisé des tests grâce au programme suivant:

volatile long compteur = 0;

void reagir()
{
  compteur++; // interruption 0 reliée à la patte n°2 de l'arduino
}

void setup() {
  Serial.begin(9600);
  attachInterrupt(0, reagir, CHANGE); // incrémentation de la variable compteur à tout les fronts envoyés par le capteur
}

void loop() {
  Serial.println(compteur);
  delay(100);
}

• Ensuite, avec l'aide de ce programme, nous avons relevé les valeurs en fonction de la quantité d'eau qui passait dans le capteur. On obtient le tableau suivant:

Mesure capteur

Quantité (ml)	100	200	300	400	500
vitesse lente	264	490	737	998	1204
vitesse moyenne	241	506	750	1000	1222
vitesse rapide	248	486	738	1009	1218
valeur moyenne	251	494	741,7	1002,3	1214,7

• Avec toutes ces valeurs, on peut donc tracer la courbe qui nous donnera l’équation de la quantité en ml en fonction du nombre de valeur envoyé par le capteur.

Composants utilisés/ables

Nom	Type	Boîtier	Librairie Eagle	Référence eagle	Documentation	Fournisseur	Référence
SI2336DS	N-MOS	SOT23			datasheet
touchscreen					documentation

Datasheets et informations techniques

• capteur volumétrique
  • 974-9522-b
  • Dans la doc si dessous et (surtout) avant de cabler bien lire et comprendre la rubrique MEASUREMENT TIPS
    • media:flowmeterDatasheet.pdf
• pompe
  • 230 VAC
  • 48W
• résistance chauffante
  • 230 VAC
  • 1500W
• flotteur
  • contact normalement fermé