LEI400
Distributeur de boisson Bianchi LEI400.
Sommaire
- 1 Présentation du projet:
- 2 Partie S3, Prototypage
- 2.1 Etude de la machine:
- 2.2 Composants utilisés/ables
- 3 Partie S4
- 4 Soucis sur la machine, différence avec les schémas
- 5 Datasheets et informations techniques
- 6 Ressources
- 7 Fabrication et tests :
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 dispose de cartes électronniques qui ne fonctionnent plus.
Il nous faut donc recréer une carte de puissance et une carte de gestion de façon à la refaire marcher.
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.
Le cahier des charges nous impose que la quantité de sucre, la température de chauffe de l'eau, la chutte d'un gobelet ou non soient personnalisable.
Documentation:
DOC 1
DOC 2, Utilisateur
DOC 3, Technique
Partie S3, Prototypage
Etude de la machine:
Etude des capteurs:
Capteur volumétrique:
- 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:
| 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.
Capteur de Température
Le capteur de températeur est une thermistance, dans un premier temps nous avons fait plusieurs mesures pour obtenir une courbe (et donc l'équation de température en fonction de la tension mesurée) la plus précise. Sur l'image si dessous nous réalisons la dernière mesure de température.
Programme permettant de valider l'équation de température:
#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.print("Temp: ");
Serial.println(Temp);
Serial.print("RT: ");
Serial.println(RT);
Serial.print("Tension aux bornes de RT : ");
Serial.println(vRt);
delay(1000);
}
Celui-ci nous donnera la température en fonction de la tension d'entrée sur le pin A0. Les lignes en commentaire montrent que l'équation de température n'est pas encore stabilisée.
10/11/2016
Une dernière mesure nous a permis de trouver une courbe correcte et d'en tirer une équation polynomiale de degré 3, (pour plus de précision), qui sera par la suite implémentée dans le programme. Voici la courbe :
Le logiciel calcule l'équation de température présente sur le graph en fonction de la courbe de température qui varie ici de 32°c à 60°c.
Les lignes à changer dans le programme sont donc :
RT=(vRt*resistanceserie)/(5.0-vRt);
RT=RT/1000.0;
Temp=-22.5713253882*log(RT)+128.4928564645; Nouvelle équation (celle trouvée grâce à la courbe) corrigée le 01/12
}
Montage arduino :
On perçoit la résistance de 10kOhm montée en série avec la thermistance. Les fils orange et bleu que nous voyons sur l'image correspondent à la thermistance.
17/11/2016
Le but de cette séance est de faire un programme qui permet de réguler la température à 40°C. Ce programme devra contrôler l'optocoupleur de la carte de puissance qui contrôlera la résistance chauffante. Notre premier programme consistait à couper le triac lorsque la température atteint 40°C.Cependant, 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 si la période dure 1sc.
Conclusion:
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 a était testé avec une résistance et un oscilloscope et est fonctionnel.
Étude de la carte bouton:
On va utiliser le MCP23017 de Microchip qui est une extension d’entrées / sorties (GPIO) 16 bits sur bus I2C qu'on branchera dans les pin A4 et A5 de l'Arduino.
Courant Max: Le MCP23017 est capable de supporter 20mA par sortie avec un courant max ne pouvant pas dépasser 150mA sur VSS (limite du MCP23017)
Dans un première temps le but est d'afficher sur le port série de l'arduino la valeur correspondant au bouton appuyé.
Schéma de liaison
Boutons poussoirs
Prototype: Carte de contrôle des 5 électrovannes:
Schéma:
Carte réalisée:
Le 18/11/2016 Carte testée et fonctionnelle.
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.
Le 18/11/2016 Carte testée et fonctionnelle.
Utilisation du montage
Ce montage va nous permettre de contrôler la pompe à eau et la résistance chauffante.
Etude du bloc café:
Ce groupe se décompose en plusieurs parties :
- La première partie, le moteur :
Ce moteur sera alimenté en 24V continue et en charge il peut consommer jusqu'à 4A.
- Le deuxième partie, le capteur et l'électroaimant :
Après avoir réaliser quelques test, on s'est rendu compte que ce capteur était normalement fermé, de plus l'électroaimant s’alimente aussi en 24V.
Pour contrôler tout ce groupe, on utilise une carte arduino et ce relais 
grâce au montage suivant :
Ce relais ferme le contact lorsque l'on relie la commande au GDN, c'est à dire lorsque l'on met un 0 sur la patte de l'arduino et inversement lorsque l'on met un 1 le contact s'ouvre. Le programme suivant va allumer le moteur pour moudre le café, ensuite une fois le compartiment de café moulu plein, le capteur s'ouvre ce qui entraîne l’arrêt du moteur et l'activation durant un petit laps de temps de l'électroaimant pour récupérer le café moulu.
int moteur = 5;
int electro = 6;
int capteur;
void setup() {
pinMode(moteur, OUTPUT);
pinMode(electro, OUTPUT);
pinMode(7, INPUT_PULLUP);
Serial.begin(9600);
}
void loop() {
capteur = digitalRead(7);
digitalWrite(moteur, LOW); // relais moteur activé
digitalWrite(electro, HIGH); // relais électroaimant désactivé
if (capteur == 1)
{
digitalWrite(moteur, HIGH);
digitalWrite(electro, LOW);
delay(150); // ouverture de l'électroaimant pendant un certain temps
digitalWrite(electro, HIGH);
delay(2500);
}
}
Pour le moment, le test n'a été fait que sur des leds , même s'il a été concluant, on fera le câblage sur le bloc café la séance prochaine.
Tests(démarches et étapes pour parvenir aux résultats finaux présentés si dessus):
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é.
| 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.
On obtient donc ce montage:
L’électrovanne d'arrivé d'eau est modélisée par une inductance, et le flotteur par un bouton.
Conception de la carte de gestion sur Eagle :
A travers cette partie, nous verrons les différentes étapes liées à la conception de la carte de gestion finale que nous devrons réaliser pour commander la machine. Dans un premier temps nous réaliserons plusieurs cartes de façon à découper le travail et à être plus efficace pour le dépannage et les tests. Les cartes communiquerons entre elles par liaison I2C.
Réalisation du schéma électrique
La réalisation du schéma électrique sur Eagle s'est effectuée au fil des différentes séances et regroupe l'ensemble du travail effectué par chaque binôme. Pour réaliser ce schéma sur le logiciel, nous nous sommes servis du schéma électrique de la machine à café comme base.
Nous avons dû également créer divers composants sur Eagle qui n'étaient présents dans aucune librairie existante.
Création de composants sous Eagle
Pour la réalisation des différentes cartes, nous avons dû créer de nouvelles librairies sur Eagle pour pouvoir utiliser certains composants.
Pour cela, on crée une nouvelle librairie auquel on ajoute une représentation pour le schéma électrique (qui contient plusieurs pins) et un modèle pour le routage (en relevant les dimensions du composant dans la documentation technique ou avec un pied à coulisse). Il n'y a plus qu'à connecter ces deux parties pour obtenir le composant sous Eagle.
| Composant | Référence | Fabricant | Documentation |
| Connecteur fil-à-carte 6 contacts | MULTICOMP MC34661 | Farnell | http://fr.farnell.com/multicomp/mc34661/embase-male-droit-6voies/dp/1578493 |
| Connecteur fil-à-carte 8 contacts | MULTICOMP MC34663 | Farnell | http://fr.farnell.com/multicomp/mc34663/embase-male-droit-8voies/dp/1578494 |
| Phototriac | G3MB | Omron | http://www.rhydolabz.com/documents/29/Solid_State_Relay_g3mb_datasheet.pdf |
| Relai | SLA-24VDC-S-L-A | Songle | https://www.elecrow.com/download/songle%20SLA.pdf |
Routage de la carte
Nous utiliserons plusieurs circuits intégrés de type MCP230xx, il faut donc leur configurer une adresse propre de façon à ce que l'on puisse communiquer avec chacun d'entre eux par I2C. Pour se faire il suffit de relier les pattes A0, A1 et A2 des MCP soit au GND soit au VCC.
| A2 | A1 | A0 | |
| Carte boutons | 0 | 0 | 0 |
| Carte moteur | 0 | 0 | 1 |
| Carte Pompe, RCh, Aspi | 0 | 1 | 0 |
| Carte électrovannes | 1 | 0 | 0 |
| Carte électroaimants | 1 | 0 | 1 |
| Carte capteurs | 1 | 1 | 0 |
| Carte gobelets | 1 | 1 | 1 |
Exportation des fichiers
Carte capteur:
Schema: Fichier:CCapteur.sch Board: Fichier:CCapteur.brd
Typons:
Carte testée et op le 14/01 à 15h.
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 |
Partie S4
a
Un oubli du S3, la carte gobelet
a
Réalisation des cartes finales
a
Schéma: Les changements.
a
Principes de routage.
a
Les erreurs oubliées.
a
Fichier EAGLE .sch et .brd
a
Cartes finales
a
Shield BB non corrigé
a
Shield arduino
a
Programmation
a
Interface seule
a
Quelques infos sur le programme
a
zip du projet sur Qt
a
Bug et erreurs connues
a
Les difficultées rencontrées
a
Gestion du temps
a
Soucis sur la machine, différence avec les schémas
a
Datasheets et informations techniques
- capteur volumétrique
- 974-9522-b
| Composant | Fonction | Tension | Puissance/Courant | Précision |
|---|---|---|---|---|
| Pompe à eau | Circulation de l'eau sous pression | 230 VAC | 48 W | |
| Résistance chauffante | Chauffer l'eau dans la cuve | 230VAC | 1320 W/6A | |
| Flotteur | Niveau d'eau dans le réservoir | 24 V | contact normalement fermé | |
| Électroaimant sucre | Quantité de sucre versé | 24 V | 48W/2A | |
| Électroaimant moulin à café | Faire tomber le café | 24V | 72W/3A | |
| Contact moulin à café | Niveau de café | 5V/Pull-up | Contact normalement fermé | |
| Contact compression | Chargement en café puis remplir d'eau | |||
| 2 Contacts en série | présence gobelets et rotation colonne | |||
| Moteur bec verseur sucre | Position du bec verseur | 24 V | 2.4W/0.1A | Fonctionne dans les deux sens |
| Moteur moulin à café | Moudre le café | 24V | 96W/4A | |
| Moteur compression café | Compresser le café | 24V | 9.6W->24W/0.4A->1A | |
| 5 x Moteurs vis sans fin | Faire tomber les ingrédients | 24V | 24W/1A | |
| 2 x Moteurs mélangeur | Mélanger les ingrédients | 24V | 24w/1A | |
| Moteur mélangeur | Mélanger les ingrédients | 24V/-24V | 24W/1A | Changement de sens en fonction du signe de la tension |
| 2 Moteurs distrib gobelet et colonne | Faire tourner l'ensemble si besoin et donner un gobelet | 24V | 0.96W/0,04A | |
| Electrovanne Arrivée d'eau | alimenter la machine en eau | 24VDC | 400mA | Normalement fermée, sécurité débordement mecannique |
| Electrovanne de distribution | alimenter la machine en eau | 24VDC | 19W | marque Olab SERIE 8000 |
Ressources
- BeagleBoneBlack/Green
- utilisation du mdule eQEP
- A utiliser avec le capteur volumétrique
- https://github.com/Teknoman117/beaglebot/blob/master/encoders/dts/README.md
- utilisation du mdule eQEP
- Principe de routage
Fabrication et tests :
Création des schémas, répartition des tâches :
Dans un premier temps, nous nous sommes partagés les tâches, c'est à dire que : Au vu du schéma général de l'installation, nous avons 8 borniers (en comptant le bornier pour les boutons poussoirs) à gérer. Il faut également une carte pour programmer le tout. Cela fais donc 9 éléments à réaliser ce qui est assez conséquent. Nous avons donc décidé de diviser le travail et même de rassembler deux borniers sur la même carte puisqu'ils contrôlent tous les deux les moteurs. La répartition s'est faite ainsi :
- M.MOHAMMEDI : carte du bornier "OUT 5" du schéma ci-dessous
- M.JOLY : carte du bornier "OUT 2" du schéma ci-dessous
- M.LECLERC et M.MANS : carte du bornier "OUT 7" du schéma ci-dessous
- M.ROBINET : carte du bornier "IN 1" du schéma ci-dessous
- M.MILLARD : carte des borniers "OUT 1 et OUT 3" du schéma ci-dessous
- M.NAMBI : carte de gestion des boutons poussoirs
- M.LEVESQUE : carte de gestion de l'ensemble
- M.MAZOUZI : carte de commande des électrovannes
