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
Au cours du semestre 3 nous avions pour but de réaliser un café, maintenant que c'est fait, il nous faut réaliser d'autres boissons.
Dans un premier temps nous avons cherché à corriger les erreur et oublis du semestre 3.
Un oubli du S3, la carte gobelet
Pendant le S3 nous n'avons pas prototypé de cartes gobelets cependant nous nous étions intérréssé au fonctionnement de l'ensemble et nous avions vu que la carte pouvait
être ralisée de la même manière qu'une carte moteur de base.
Réalisation des cartes finales
Nous avons passé une bonne partie du semestre à re-créer les cartes prototypées au S3. On a du redimensionner les composants qui ont été sous-dimensionnés, ajouter quelques sécurités
corriger les erreurs vu au S3 et surtout miniaturiser les cartes de façon à ce qu'elles tiennent toutes sur une carte mère de la taille de la carte d'origine.
Le groupe puissance charger de controller pompe, chaudière et aspirateur sera situé sur la carte mère.
Schéma: Les changements.
a
Principes de routage.
Piste GND et 24V le plus large possible pour éviter un echauffement dû au passage du courant
On garde la position d'origine des borniers de façon à ne pas devoir recabler la machine
Toutes les petites cartes doivent s'adapter dessus.
Les erreurs oubliées.
Ces problèmes ne sont pas forcement corrigés sur les schéma présent si dessous.
Sur la carte capteur: La masse commune est reliée à la masse du capteur volumétrique. Il ne faut pas oublier de la relier.
Sur la carte gobelet, problème de routage des PHP 225
Sur la carte electrovannes,
Sur le shield Beaglebone, un court-circuit sur la face bottom, les entrées analogiques pour la thermistance ne sont pas juste (connexion au 1.8v(vdd ADC)à réaliser et suppression du deuxième pont diviseur)
Fichier EAGLE .sch et .brd
Attention certaines erreurs peuvent rester sur ces documents. Merci de vérifier avec la liste si dessus.
Cartes finales
a
Shield BB non corrigé
Les entrées pour la thermistance ne sont pas bonnes, il y a un court circuit sur l'entrée AN4 avec le GND sur la couche BOTTOM et le 5V doit venir de SYS_5V et pas VDD_5V.
sch et brd: Fichier:ShieldBB.zip
Shield arduino
a
Programmation
La programmation à été réalisée en C++ grâce à l'IDE QTCreator.
Interface seule
Interface QT
Ci dessus l'interface graphique du programme final, les icônes des pages debugs ne marchent pas puisqu'ils sont liés à l'état des sorties qui ne sont pas encore implémentées
Quelques infos sur le programme
Le programme n'utilise pas les QThread, il freeze donc de temps à autres.
La page d'initialisation disparait seulement quand la température de 70°C est passée.
Si après le choix d'une boisson la page 'préparation boisson' reste il faut supprimer le QTimer à la ligne 1165 et le remplacer par boisson(choix);
Nous n'avions pas eu le temps de tester cette modif avant la soutenance.
La création de la boisson est lancée par le passage à la page d'index 9 (méthode changeIndex 9).
Chaque bouton (sauf menu et popup) est dans un groupe ou il se voit attribuer un ID. Chaque groupe dispose de sa méthode clicked(), on detecte ensuite l'ID renvoyé et on applique le choix en question.
La variable choix[] determine la boisson choix[0]=boisson(entre 0 et 15), choix[1] et choix[2] option lait et sucre. L'option 'j'ai mon gobelet' est à part.
Le programme pour les gobelets fonctionne cependant les gobelets utilisés ne tombent pas forcement bien.
Il n'y a pas de mise en veille gérée pas non plus de vidange programmée
Il faut appuyer 6 fois sur le bouton info pour debloquer le debogage.
Les sorties ne sont pas toutes remises à 0 à l'extinction du programme de Plus les pointeurs ne sont jamais supprimés. C'est surement à corriger pour éviter des fuites mémoires.
zip du projet sur Qt et petites doc correspondantes
On a modifié quelques petites choses juste avant la soutenance mais ça n'a pas été testé. Cela n'aura pas d'impact sur le fonctionnement de la machine mais il peut y avoir quelques erreurs de compilation (méthode supprimées dans le .cpp et pas .h ou reste de référence à des élèments supprimés du .ui non supprimés dans le .cpp)
Programme LEI
Liste des E/S et leurs noms correspondant dans le programme Il peut y avoir des erreurs sur les OUT
Infos sur les boutons et leurs groupes
Bug et erreurs connues
Dans l'onglet débogage l'image de l'arrivée d'eau ne s'adapte pas forcement à l'état de l'electrovanne, en effet quand la regulation du niveau coupe l'arrivéeelle ne met pas à jour l'image.
Si on appui sur le bouton de changement d'arrière plan sur le menu les icones grossisent, c'est dû au fait que l'on applique pas l'attribut margin au changement de feuille de style.
Les difficultées rencontrées
a
Gestion du temps
a
Soucis sur la machine, différence avec les schémas
Sur le OUT3 le +24V à dû être changé de place, en effet de base il n'était pas cablé comme indiqué sur le schéma.
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"
- M.JOLY : carte du bornier "OUT 2"
- M.LECLERC et M.MANS : carte du bornier "OUT 7"
- M.ROBINET : carte du bornier "IN 1" Shield BB et arduino final, programme BB, dépannages, carte capteur.
- M.MILLARD : carte des borniers "OUT 1 et OUT 3"
- M.NAMBI : carte de gestion des boutons poussoirs
- M.LEVESQUE : carte de gestion de l'ensemble, prog arduino, dépannages
- M.Mans : carte mère
- M.MAZOUZI : carte de commande des électrovannes, interface graphique QT
