Accueil

Machine à liqueur

Objectif de la lecture

Dans un de mes cours de troisième année, j'ai eu à concevoir et construire un projet de mon choix, et j'ai décidé de faire une machine à liqueur, un distributeur de cocktails automatisé piloté par un Arduino. Dans cet article, je documente toutes les étapes que j'ai suivies, du premier branchement jusqu'au résultat final, afin de montrer comment j'y suis arrivé.

1. Matériel utilisé

Jettant un coup d'oeil sur la matériel nécaissaire dont je me suis servie pour construire la machine

  1. Micro-contrôleur : Arduino UNO
  2. Écran LCD 20x4 avec module I2C soudé au dos
  3. Clavier matriciel 4x4
  4. Module 4 relais
  5. Breadboard
  6. Adaptateur d'alimentation 12 V 3 A
  7. Trois petites pompes à eau 12V
  8. Fils de connexion (jumpers)

2. Code et explications

// Importer les librairies nécessaire
#include <Wire.h>                   // Pour la communication avec le module I2C de l'écran LCD
#include <LiquidCrystal_I2C.h>      // Pour controler l'écran LCD
#include <Keypad.h>                 // Pour lire les Inputs du pavé numérique

// On crée l'objet "lcd" : une variable qui va représenter notre écran dans le code
LiquidCrystal_I2C lcd(0x27, 20, 4); // 0x27 : son adresse, 20 : nombre de colonnes, 4 : nombre de lignes

// Dimensions du pavé numérique
const byte lignes = 4;
const byte colonnes = 4;

// On associe les touches du clavier numérique aux pines de l'arduino
char clavier[lignes][colonnes] = {  // Crée un tableau de 2 dimensions qui va représenter notre pavé numérique dans le code
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};
byte pinesL[lignes] = {9, 8, 7, 6};        // On dit à arduino sur quels pines sont branchés les 4 fils de lignes
byte pinesC[colonnes] = {5, 4, 3, 2};      // On dit à arduino sur quels pines sont branchés les 4 fils de colonnes
Keypad numpad = Keypad(makeKeymap(clavier), pinesL, pinesC, lignes, colonnes);

// On associe un nom lisible aux pines de l'arduino
const int pompe_rouge = 11;
const int pompe_bleue  = 12;
const int pompe_jaune = 13;

// Les relais utilisés ici sont actifs à l'état bas (LOW allumé, HIGH éteint). Une variable pour chaque état
const int relais_on  = LOW;
const int relais_off = HIGH;

// Variable pour représenter 26 secondes en ms
const int duree = 26000;

// On créé un type de variable (une structure) pour repésenter les boissons (leurs compositions)
struct Boisson {
  String nom;
  int pompe1;
  int pompe2; // Ici on va passer la valeure -1 si c'est un shooter pour ne pas actionner la deuxième pompe
};

// On crée un tableau pour nos boissons pour définir leurs recettes
const int nb_boissons = 6;
Boisson boissons[nb_boissons] = {
  {"Shooter rouge", pompe_rouge, -1},
  {"Shooter jaune", pompe_jaune, -1},
  {"Shooter bleu",  pompe_bleue,  -1},
  {"Drink violet",  pompe_rouge, pompe_bleue},
  {"Drink orange",  pompe_rouge, pompe_jaune},
  {"Drink vert",    pompe_bleue,  pompe_jaune}
};

// Un index qui servir comme index de boisson
int curseur = 0;

// Une fontion qui va afficher le menu des boissons
void afficherMenu() {
  lcd.clear(); // On efface tout ce qui est présent sur l'écran
  lcd.setCursor(0, 0); // On dit à l'écran LCD d'aller à la position 0,0 de lui meme
  lcd.print("Choisissez boisson:"); // Puis écrire Choisissez boisson (max 20 caractères)
  lcd.setCursor(0, 1); // Ensuite on lui dit déplace toi vers la position 0,1
  lcd.print("> "); // Et écrit : "> "
  lcd.print(boissons[curseur].nom); // et sur la meme place, donc juste aprés le "> ", écrit le nom de la boisson pointé par la variable curseur
}

void setup() {
  pinMode(pompe_rouge, OUTPUT); // On dit à arduino que ces pines là sont output (c'est elle qui vont envoyer un signal)
  pinMode(pompe_bleue, OUTPUT);
  pinMode(pompe_jaune, OUTPUT);
  digitalWrite(pompe_rouge, relais_off); // Puis on lui demande d'envoyer le signal OFF (HIGH). Comme ca de base tout les relais, donc les pompes, sont OFF.
  digitalWrite(pompe_bleue, relais_off);
  digitalWrite(pompe_jaune, relais_off);

  lcd.init(); // Initialiser le LCD
  lcd.backlight(); // Allumer le LCD
  afficherMenu(); // Appeler le fonction chargé d'afficher le menu boissons
}

void servir(Boisson b) {

  // Effacer le contenu affiché sur le LCD et écrire Preparation + le nom de la boisson qu'elle recoit en paramètre
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Preparation...");
  lcd.setCursor(0, 1);
  lcd.print(b.nom);

  // Envoyer le signal ON aux relais pour alimenter les pompes correspondantes à la boisson choisie
  digitalWrite(b.pompe1, relais_on); // Alimenter la première pompe (toujours)
  if (b.pompe2 != -1) digitalWrite(b.pompe2, relais_on); // Vérifier si le paramètre pompe2 de la boisson n'est pas -1, si c'est pas le cas alimenter le deuxième pompe

  delay(duree); // Chronomètre de 26 secondes

  digitalWrite(b.pompe1, relais_off); // Éteindre la première pompe
  if (b.pompe2 != -1) digitalWrite(b.pompe2, relais_off); // Éteindre la deuxième si y on a

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Pret !"); // Écrire pret
  delay(2000); // Chrono 2 secondes

  afficherMenu(); // réafficher le menu
}

// Code qui va s'executer tout seul un nombre de fois par seconde
void loop() {
  char touche = numpad.getKey(); // Lire la touche du clavier pressée

  if (touche == 'A') {
    curseur = (curseur + 1) % nb_boissons; // On clique sur A pour auguementer le curseur et passer à la prochaine boisson
                                           // modulo % premet de repasser à 0 après 5 (faire une boucle)
    afficherMenu();
  }

  else if (touche == 'C') {
    curseur = (curseur - 1 + nb_boissons) % nb_boissons; // On clique sur C pour diminuer le curseur et repasser à la boisson précédente
                                                         // modulo % premet de faire une boucle dans le sens inverse
                                                         // + nb_boissons pour éviter les nombres négatifs
    afficherMenu();
  }

  else if (touche == 'B') {
    servir(boissons[curseur]); // On clique sur B pour servir la boisson correspendante (choisie)
  }
}

3. Étapes de réalisation

Étape 1 : Préparer le câble d'alimentation

Adaptateur 12 V dont le câble a été coupé et raccordé à deux fils de connexion

Le montage est alimenté par un adaptateur secteur de 12 V. Son câble se termine par une fiche ronde, impossible à brancher directement sur une breadboard. J'ai donc coupé le câble et je l'ai raccordé à deux fils de connexion. Le fil rouge transporte le +12 V et le fil noir la masse (GND, 0 V). Il faut respecter cette polarité : inverser les deux fils pourrait endommager les composants.

Étape 2 : Brancher l'alimentation sur la breadboard

Fils d'alimentation branchés sur le rail latéral de la breadboard

J'ai ensuite branché les deux fils sur le rail latéral de la breadboard : le rouge sur la ligne marquée « + », le noir sur la ligne marquée « − ». Chaque rail est relié électriquement sur toute sa longueur, ce qui veut dire qu'on retrouve la même tension à n'importe quel endroit de la ligne. Cette ligne est maintenant une ligne d'alimentation de 12 V, qui servira à distribuer le courant à tous les composants du projet.

Étape 3 : Préparer l'alimentation de l'Arduino

Deux fils branchés sur les broches GND et VIN de l'Arduino

J'ai branché deux fils sur l'Arduino : un sur la broche GND et l'autre sur la broche VIN. La broche VIN est l'entrée prévue pour une alimentation externe. L'Arduino fonctionne en 5 V, mais un régulateur de tension intégré à la carte convertit automatiquement les 12 V reçus. La broche GND est la masse : elle permet au courant de retourner vers l'adaptateur, sans quoi le circuit ne serait pas fermé. Elle sert aussi de référence commune à tout le montage.

Étape 4 : Brancher l'Arduino sur la ligne 12 V

Arduino relié au rail d'alimentation 12 V de la breadboard

Enfin, j'ai branché l'autre extrémité des deux fils de l'Arduino sur la ligne alimentée en 12 V : le fil rouge (VIN) sur le « + » et le fil noir (GND) sur le « − ». L'Arduino est maintenant alimenté par l'adaptateur, sans passer par le câble USB. La ligne reste disponible pour alimenter les autres composants à mesure que je les ajoute.

Étape 5 : Brancher des fils sur l'écran

Écran LCD 20x4 vu de face avec ses fils de connexion Dos de l'écran LCD avec le module I2C et ses quatre fils

Avant de relier l'écran au reste du montage, j'ai branché quatre fils de connexion sur le module I2C, la petite carte soudée au dos de l'écran. Sans ce module, l'écran aurait demandé une dizaine de fils. Le module agit comme un traducteur et réduit tout à quatre broches : GND (la masse), VCC (l'alimentation en 5 V), SDA (les données) et SCL (l'horloge, qui cadence les échanges). Les deux dernières forment un bus appelé I2C, et c'est par là que l'Arduino enverra le texte à afficher.

Étape 6 : Créer une ligne d'alimentation en 5 V

Deux fils reliant les broches 5V et GND de l'Arduino au second rail de la breadboard

Mon alimentation fournit 12 V, mais l'écran fonctionne en 5 V : le brancher sur la ligne 12 V l'endommagerait. J'ai donc créé une deuxième ligne d'alimentation. L'Arduino contient un régulateur de tension qui transforme les 12 V reçus en 5 V stables, disponibles sur sa broche 5V. J'ai relié cette broche (fil rouge) et une broche GND (fil brun) à l'autre rail de la breadboard. Ce rail distribue maintenant du 5 V, et la masse commune garantit que tout le montage partage la même référence électrique.

Étape 7 : Brancher l'écran sur le 5 V et sur l'Arduino

Écran LCD relié à la ligne 5 V de la breadboard et aux broches SDA et SCL de l'Arduino

Il reste à brancher l'écran. Les fils VCC et GND vont sur la ligne 5 V, ce qui l'alimente. Les fils SDA et SCL vont directement sur les broches SDA et SCL de l'Arduino (reliées en interne à A4 et A5). L'écran n'a donc pas besoin de recevoir ses données par la ligne d'alimentation : l'Arduino, qui est le cerveau du montage, lui envoie le texte par ces deux fils. C'est ce qui permet, dans le code, d'utiliser la librairie Wire pour communiquer avec lui.

Étape 8 : Préparer le clavier matriciel

Clavier matriciel 4x4 avec sa nappe de connexion Connecteur à 8 broches numérotées du clavier avec les fils de connexion branchés

Le clavier matriciel compte 16 touches, mais il ne sort que 8 fils : 4 pour les lignes et 4 pour les colonnes. Chaque touche est placée à l'intersection d'une ligne et d'une colonne. Quand on appuie, elle relie les deux, et l'Arduino retrouve la touche en repérant quelle ligne et quelle colonne se sont connectées. Ce système économise 8 broches par rapport à un fil par touche. Sa nappe se termine par un connecteur à 8 positions numérotées de 1 à 8, sur lequel j'ai branché un fil de connexion par broche.

Étape 9 : Brancher le clavier sur l'Arduino

Les 8 fils du clavier branchés sur les broches numériques 2 à 9 de l'Arduino

J'ai branché les 8 fils du clavier sur les broches numériques 2 à 9 de l'Arduino : les broches 9, 8, 7 et 6 pour les lignes, et 5, 4, 3 et 2 pour les colonnes. Ces broches doivent correspondre à celles déclarées dans le code, sinon l'Arduino lirait les mauvaises touches. Le clavier n'a pas besoin d'alimentation : ses touches sont de simples interrupteurs, et c'est l'Arduino qui envoie un signal électrique pour détecter laquelle est enfoncée.

Étape 10 : Présenter le module de relais

Module de 4 relais avec ses broches de commande

Un relais est un interrupteur commandé électriquement. J'en ai besoin parce qu'une broche de l'Arduino ne peut fournir qu'un très faible courant, bien trop peu pour faire tourner les pompes, qui fonctionnent en 12 V. Le relais règle le problème : l'Arduino envoie un petit signal de 5 V, et le relais ferme alors un circuit séparé capable d'alimenter la pompe. Le module en regroupe quatre. Il a six broches de commande : Gnd, In1 à In4 (une entrée par relais) et Vcc. Le cavalier jaune garde l'alimentation des bobines des relais sur le même 5 V que le reste de la carte.

Étape 11 : Alimenter le module de relais en 5 V

Broches Gnd et Vcc du module de relais reliées à la ligne 5 V de la breadboard

J'ai d'abord alimenté la partie commande du module, son « cerveau », celle qui reçoit les ordres de l'Arduino et fait basculer les relais. Elle fonctionne en 5 V : j'ai relié ses broches Gnd et Vcc à la ligne 5 V de la breadboard. La ligne 12 V ne doit pas être utilisée ici, car elle abîmerait ces circuits. Les 12 V serviront plus tard seulement du côté des pompes, à travers les contacts des relais.

Étape 12 : Brancher les entrées des relais sur l'Arduino

Entrées In1 à In3 du module de relais reliées aux broches 11, 12 et 13 de l'Arduino

Enfin, j'ai relié les entrées In1, In2 et In3 aux broches 11, 12 et 13 de l'Arduino. Chaque broche commande un relais, donc une pompe : rouge, bleue et jaune. Quand le programme met une broche à l'état bas (LOW), le relais se ferme, et la pompe démarre. Une fois la pompe arrêtée, le programme remet la broche à HIGH. Seuls trois des quatre relais sont utilisés, puisque j'ai trois pompes : l'entrée In4 reste libre.

Étape 13 : Comprendre les bornes d'un relais

Gros plan sur les trois bornes à vis d'un relais

Chaque relais possède trois bornes à vis. Celle du milieu est la borne commune (COM) : c'est l'entrée du courant. Les deux autres sont les sorties possibles. Un relais est un interrupteur : à l'intérieur, une petite lame métallique relie la borne commune à l'une des deux sorties. Quand le relais n'est pas activé, la lame touche une seule des deux bornes. Cette borne est dite « normalement fermée » (NC) : elle est connectée à la borne commune par défaut. L'autre est dite « normalement ouverte » (NO) : elle n'est pas connectée par défaut. Quand l'Arduino active le relais, la lame bascule et les rôles s'inversent. Pour les distinguer, la carte affiche un petit symbole d'interrupteur près des bornes. Si la lame du dessin est dirigée vers une borne, celle-ci est fermée au repos. Si elle ne l'est pas, la borne est ouverte au repos.

Étape 14 : Brancher le +12 V sur le relais

Fil reliant la ligne + 12 V de la breadboard à la borne commune du relais

Le relais joue le rôle d'un interrupteur placé sur le fil positif de la pompe. J'ai donc « coupé » ce fil en deux : le +12 V arrive depuis la ligne d'alimentation jusqu'à la borne du milieu du relais (COM), et la suite du fil repartira de la borne « normalement ouverte » (NO). Couper un seul des deux fils suffit pour interrompre le circuit. J'ai choisi la borne NO plutôt que NC pour que la pompe reste éteinte par défaut. Ainsi, au démarrage ou si l'Arduino perd son alimentation, aucun liquide ne coule par accident.

Étape 15 : Brancher la pompe

Pompe reliée à la borne NO du relais et à la ligne négative de 12 V

J'ai relié le fil positif de la pompe à la borne « normalement ouverte » (NO) du relais, et son fil négatif directement à la ligne négative du 12 V. Le circuit est donc complet, mais interrompu au niveau du relais. Quand l'Arduino active le relais, la lame ferme le contact entre la borne commune et la borne NO. Le courant circule alors du +12 V, à travers le relais, jusqu'à la pompe, puis revient par la ligne négative, et la pompe démarre. Quand le relais se désactive, le circuit s'ouvre à nouveau et la pompe s'arrête. Le même principe s'applique à chaque pompe supplémentaire, avec son propre relais.

Étape 16 : Téléverser le code dans l'Arduino

Câble USB branché sur le port USB de l'Arduino

Il reste à donner ses instructions à l'Arduino. Je le relie à mon ordinateur avec un câble USB, branché sur son port USB carré. Dans l'IDE Arduino, je choisis le modèle de carte (Arduino Uno), puis le port série sur lequel l'Arduino apparaît dans le menu Outils > Port. Sous Windows, il porte un nom comme « COM3 » (le numéro varie d'un ordinateur à l'autre). Le bouton Téléverser compile le code et l'envoie dans la mémoire de l'Arduino. Le programme y reste enregistré, et il démarre automatiquement chaque fois que la carte est alimentée.

Étape 17 : Le montage final

Montage final : Arduino, écran LCD, clavier matriciel, relais et pompe

Voici le montage terminé. L'adaptateur de 12 V alimente l'Arduino et la ligne des pompes. L'Arduino produit le 5 V qui alimente l'écran et le module de relais. Le clavier envoie à l'Arduino les touches choisies par l'utilisateur, l'écran affiche le menu des boissons, et les relais commandent la pompe qui sert la boisson.

Étape 18 : Construire le gabarit en bois

Gabarit en bois vu de face et de dos, avec la fenêtre de l'écran, l'emplacement du clavier et la sortie des broches du clavier

Un montage éparpillé sur une table n'est ni pratique ni fiable : les fils se débranchent facilement et l'ensemble ne ressemble pas à une vraie machine. J'ai donc construit un gabarit en bois qui rassemble tout le projet. Sa base large et décalée lui donne de la stabilité. La boîte du haut place l'écran et le clavier à hauteur de main : l'écran est visible par une fenêtre découpée dans le bois, et le clavier est encastré juste en dessous. La nappe du clavier ressort par une fente, au bas de son emplacement, pour rejoindre l'électronique. La breadboard et le module de relais reposent sur la tablette, ce qui garde le câblage accessible pour les réglages. L'utilisateur ne voit que l'écran et le clavier. (Photo retouchée par IA pour plus de clarté.)

Étape 19 : Ajouter les contenants, les tubes et la sortie

Le gabarit accueille aussi les liquides : trois contenants, un rouge, un jaune et un bleu, un par pompe. Chaque pompe aspire son liquide et le pousse dans un tube. Les tubes mènent tous à un trou au milieu du gabarit, au-dessus de l'endroit où l'on place le verre. Ce trou central est la sortie commune de la machine. Comme les pompes peuvent fonctionner une à la fois ou deux ensemble, la machine sert un shooter d'une couleur pure, ou un drink obtenu en mélangeant deux liquides directement dans le verre : le rouge et le bleu donnent le violet, le rouge et le jaune donnent l'orange, le bleu et le jaune donnent le vert. Le bon contenant et la bonne pompe sont ainsi choisis par le programme, selon la touche pressée.