Utiliser un bargraphe à LEDs avec une carte Arduino / Genuino

Des LEDs, encore des LEDs

Image d'entête

par skywodd | | Licence (voir pied de page)

Catégories : Tutoriels Arduino | Mots clefs : Arduino Genuino LED DEL Bargraphe

Cet article n'a pas été mis à jour depuis un certain temps, son contenu n'est peut être plus d'actualité.


Dans ce tutoriel, nous allons encore parler de LEDs, mais sous forme de bargraphe cette fois-ci. Nous verrons comment se câble un bargraphe à LEDs, comment ceux-ci fonctionnent et comment les utiliser avec une carte Arduino / Genuino. En bonus, nous donnerons un petit côté K2000 à cet article.

Sommaire

Bonjour à toutes et à tous !

On a parlé plusieurs fois des LEDs sur le site. Il existe des LEDs pour tout, éclairage, animation, affichage, etc.

Parmi toutes les formes et couleurs de LEDs disponibles, on trouve les bargraphes à LEDs. Les bargraphes à LEDs permettent d'afficher des niveaux de liquides, des informations de progression, et pleins d'autres choses.

Dans cet article, nous verrons comment mettre en oeuvre un bargraphe à LED avec une carte Arduino / Genuino.

Le bargraphe à LEDs

Bargraphe à LEDs mono-couleur rouge

Bargraphe à LEDs mono-couleur rouge

Un bargraphe à LEDs se présente sous la forme d'un petit boitier rectangulaire avec deux séries de broches en dessous.

Chaque petit rectangle plus clair contient une LED. Un bargraphe à LEDs n'est rien de plus qu'une série de LEDs rectangulaires mises bout à bout dans un même boitier.

N.B. Il existe des bargraphes à LEDs monocouleur et bicolores. Les bargraphes bicolores ont un câblage très particulier qui fera l'objet d'un article dédié. Cet article traite uniquement des bargraphes à LEDs monocouleur.

Brochage d'un bargraphe à LEDs mono-couleur

Brochage d'un bargraphe à LEDs mono-couleur

Les bargraphes à LEDs monocouleur (ici rouge) sont semblables à une série de LEDs classiques. Chaque LED à une broche pour l'anode (le "+") et une autre pour la cathode (le "-").

La broche n°1 est repérable à son coin biseauté, bien visible sur la photo un peu plus haut.

Le montage

Afin de maîtriser le câblage d'un bargraphe à LEDs, nous allons faire ensemble un petit montage de démonstration.

Photographie du matériel nécessaire à la réalisation du tutoriel Arduino Bargraphe LEDs

Matériel nécessaire

Pour réaliser ce montage, il va nous falloir :

  • Une carte Arduino UNO (et son câble USB),

  • Un bargraphe à LEDs monocouleur,

  • Dix résistances de 330 ohms (orange / orange / marron),

  • Une plaque d'essai et des fils pour câbler notre montage.

Vue prototypage du montage du tutoriel Arduino Bargraphe LEDs

Vue prototypage du montage

Vue schématique du montage du tutoriel Arduino Bargraphe LEDs

Vue schématique du montage

Pour commencer notre montage, nous allons câbler chaque cathode des LEDs à la broche GND de la carte Arduino au moyen de fils.

On câblera ensuite une résistance de 330 ohms en série avec chaque anode des LEDs.

Photographie du montage du tutoriel Arduino Bargraphe LEDs

Le montage fini

Pour achever le circuit, il convient de relier chaque résistance à une broche de la carte Arduino. J'ai choisi dans cet exemple d'utiliser les broches D4 à D13.

N.B. Les broches D0 et D1 sont réservées au port série de la carte Arduino. Ne câblez pas de LED sur ces broches sous peine de ne plus pouvoir envoyer de nouveau programme dans votre carte.

Le code

Pour cet article, nous allons réaliser trois codes d'exemples : un code d'affichage décimal, un code d'affichage par niveaux et un code d'affichage binaire.

Affichage décimal

Ce premier code d'exemple permettra d'utiliser le bargraphe comme un afficheur décimal. 1 allumera la premiére LED du bargraphe, 2 la seconde, etc.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
const byte PIN_LED_1 = 4;
const byte PIN_LED_2 = 5;
const byte PIN_LED_3 = 6;
const byte PIN_LED_4 = 7;
const byte PIN_LED_5 = 8;
const byte PIN_LED_6 = 9;
const byte PIN_LED_7 = 10;
const byte PIN_LED_8 = 11;
const byte PIN_LED_9 = 12;
const byte PIN_LED_10 = 13;

Le code commence par les classiques déclarations de constantes pour les diverses broches des LEDs.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
void setup() {
  
  /* Met les broches en sorties */
  pinMode(PIN_LED_1, OUTPUT);
  pinMode(PIN_LED_2, OUTPUT);
  pinMode(PIN_LED_3, OUTPUT);
  pinMode(PIN_LED_4, OUTPUT);
  pinMode(PIN_LED_5, OUTPUT);
  pinMode(PIN_LED_6, OUTPUT);
  pinMode(PIN_LED_7, OUTPUT);
  pinMode(PIN_LED_8, OUTPUT);
  pinMode(PIN_LED_9, OUTPUT);
  pinMode(PIN_LED_10, OUTPUT);
  
  /* Eteint les LEDs */
  afficheBargraphe(0);
}

Dans la fonction setup(), toutes les broches des LEDs sont configurées en sorties. Les LEDs sont ensuite éteintes en appelant la fonction afficheBargraphe() que nous verrons un peu plus tard dans ce chapitre.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
void loop() {
  static byte valeur = 0;
  
  // Affiche la valeur
  afficheBargraphe(valeur);

  // Incrémente la valeur de 1, revient à 0 si > 10
  if (++valeur == 11) {
    valeur = 0; 
  }
  
  // Delai pour la démo
  delay(1000);
}

La fonction loop() implémente une simple boucle avec une variable statique (qui garde sa valeur entre deux appels de loop()) nommée valeur qui prend successivement les valeurs 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, puis 10, en boucle.

Un délai d'une seconde permet d'observer l'effet sur les LEDs.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
/* Affiche la valeur (valeur = n°LED allumée) */
void afficheBargraphe(byte valeur) {
  digitalWrite(PIN_LED_1, valeur == 1);
  digitalWrite(PIN_LED_2, valeur == 2);
  digitalWrite(PIN_LED_3, valeur == 3);
  digitalWrite(PIN_LED_4, valeur == 4);
  digitalWrite(PIN_LED_5, valeur == 5);
  digitalWrite(PIN_LED_6, valeur == 6);
  digitalWrite(PIN_LED_7, valeur == 7);
  digitalWrite(PIN_LED_8, valeur == 8);
  digitalWrite(PIN_LED_9, valeur == 9);
  digitalWrite(PIN_LED_10, valeur == 10);
}

Le plus intéressant se trouve dans la fonction afficheBargraphe() qui prend en paramètre le numéro de la LED à allumer. La valeur zéro permet d'éteindre les LEDs.

L'astuce ici est d'utiliser un test de valeur, tel que valeur == 3 pour générer un booléen vrai / faux qui est utilisé par la fonction digitalWrite() pour allumer ou éteindre les différentes LEDs.

N.B. Avec ce code, au maximum, une seule LED est allumée à tout instant t.

Le code complet avec commentaires :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
/**
 * Code d'exemple d'affichage décimal pour un bargraphe à LEDs.
 */

/* Les broches */
const byte PIN_LED_1 = 4;
const byte PIN_LED_2 = 5;
const byte PIN_LED_3 = 6;
const byte PIN_LED_4 = 7;
const byte PIN_LED_5 = 8;
const byte PIN_LED_6 = 9;
const byte PIN_LED_7 = 10;
const byte PIN_LED_8 = 11;
const byte PIN_LED_9 = 12;
const byte PIN_LED_10 = 13;

void setup() {
  
  /* Met les broches en sorties */
  pinMode(PIN_LED_1, OUTPUT);
  pinMode(PIN_LED_2, OUTPUT);
  pinMode(PIN_LED_3, OUTPUT);
  pinMode(PIN_LED_4, OUTPUT);
  pinMode(PIN_LED_5, OUTPUT);
  pinMode(PIN_LED_6, OUTPUT);
  pinMode(PIN_LED_7, OUTPUT);
  pinMode(PIN_LED_8, OUTPUT);
  pinMode(PIN_LED_9, OUTPUT);
  pinMode(PIN_LED_10, OUTPUT);
  
  /* Eteint les LEDs */
  afficheBargraphe(0);
}

void loop() {
  static byte valeur = 0;
  
  // Affiche la valeur
  afficheBargraphe(valeur);

  // Incrémente la valeur de 1, revient à 0 si > 10
  if (++valeur == 11) {
    valeur = 0; 
  }
  
  // Delai pour la démo
  delay(1000);
}

/* Affiche la valeur (valeur = n°LED allumée) */
void afficheBargraphe(byte valeur) {
  digitalWrite(PIN_LED_1, valeur == 1);
  digitalWrite(PIN_LED_2, valeur == 2);
  digitalWrite(PIN_LED_3, valeur == 3);
  digitalWrite(PIN_LED_4, valeur == 4);
  digitalWrite(PIN_LED_5, valeur == 5);
  digitalWrite(PIN_LED_6, valeur == 6);
  digitalWrite(PIN_LED_7, valeur == 7);
  digitalWrite(PIN_LED_8, valeur == 8);
  digitalWrite(PIN_LED_9, valeur == 9);
  digitalWrite(PIN_LED_10, valeur == 10);
}

L'extrait de code ci-dessus est disponible en téléchargement sur cette page (le lien de téléchargement en .zip contient le projet Arduino prêt à l'emploi).

Affichage par niveaux

Dans le code du chapitre précédent, une seule LED est allumée à tout instant t. Dans ce chapitre, nous allons très légèrement modifier le code pour que toutes les LEDs jusqu'à la LED voulue soit allumées. La valeur 3 allumera les LEDs n°1, 2 et 3 par exemple. Cela va donner un véritable effet "bargraphe".

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
/* Affiche la valeur (valeur = n°LED allumée) */
void afficheBargraphe(byte valeur) {
  digitalWrite(PIN_LED_1, valeur >= 1);
  digitalWrite(PIN_LED_2, valeur >= 2);
  digitalWrite(PIN_LED_3, valeur >= 3);
  digitalWrite(PIN_LED_4, valeur >= 4);
  digitalWrite(PIN_LED_5, valeur >= 5);
  digitalWrite(PIN_LED_6, valeur >= 6);
  digitalWrite(PIN_LED_7, valeur >= 7);
  digitalWrite(PIN_LED_8, valeur >= 8);
  digitalWrite(PIN_LED_9, valeur >= 9);
  digitalWrite(PIN_LED_10, valeur >= 10);
}

La seule modification a effectuer pour obtenir un effet bargraphe est de changer la condition d'allumage des LEDs.

En faisant une condition valeur >= 3 par exemple, on allume la LED n°3, mais aussi toutes les LEDs inférieur à la LED n° 3.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
/* Affiche la valeur (valeur = n°LED allumée) */
void afficheBargraphe_inverse(byte valeur) {
  digitalWrite(PIN_LED_1, valeur < 1);
  digitalWrite(PIN_LED_2, valeur < 2);
  digitalWrite(PIN_LED_3, valeur < 3);
  digitalWrite(PIN_LED_4, valeur < 4);
  digitalWrite(PIN_LED_5, valeur < 5);
  digitalWrite(PIN_LED_6, valeur < 6);
  digitalWrite(PIN_LED_7, valeur < 7);
  digitalWrite(PIN_LED_8, valeur < 8);
  digitalWrite(PIN_LED_9, valeur < 9);
  digitalWrite(PIN_LED_10, valeur < 10);
}

Il est aussi possible d'inverser la condition pour que les LEDs soit allumées par défaut et éteintes en fonction de la valeur donnée.

Le code complet avec commentaires :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
/**
 * Code d'exemple d'affichage par niveaux pour un bargraphe à LEDs.
 */

/* Les broches */
const byte PIN_LED_1 = 4;
const byte PIN_LED_2 = 5;
const byte PIN_LED_3 = 6;
const byte PIN_LED_4 = 7;
const byte PIN_LED_5 = 8;
const byte PIN_LED_6 = 9;
const byte PIN_LED_7 = 10;
const byte PIN_LED_8 = 11;
const byte PIN_LED_9 = 12;
const byte PIN_LED_10 = 13;

void setup() {
  
  /* Met les broches en sorties */
  pinMode(PIN_LED_1, OUTPUT);
  pinMode(PIN_LED_2, OUTPUT);
  pinMode(PIN_LED_3, OUTPUT);
  pinMode(PIN_LED_4, OUTPUT);
  pinMode(PIN_LED_5, OUTPUT);
  pinMode(PIN_LED_6, OUTPUT);
  pinMode(PIN_LED_7, OUTPUT);
  pinMode(PIN_LED_8, OUTPUT);
  pinMode(PIN_LED_9, OUTPUT);
  pinMode(PIN_LED_10, OUTPUT);
  
  /* Eteint les LEDs */
  afficheBargraphe(0);
}

void loop() {
  static byte valeur = 0;
  
  // Affiche la valeur
  afficheBargraphe(valeur);
  //afficheBargraphe_inverse(valeur);

  // Incrémente la valeur de 1, revient à 0 si > 10
  if (++valeur == 11) {
    valeur = 0; 
  }
  
  // Delai pour la démo
  delay(1000);
}

/* Affiche la valeur (valeur = n°LED allumée) */
void afficheBargraphe(byte valeur) {
  digitalWrite(PIN_LED_1, valeur >= 1);
  digitalWrite(PIN_LED_2, valeur >= 2);
  digitalWrite(PIN_LED_3, valeur >= 3);
  digitalWrite(PIN_LED_4, valeur >= 4);
  digitalWrite(PIN_LED_5, valeur >= 5);
  digitalWrite(PIN_LED_6, valeur >= 6);
  digitalWrite(PIN_LED_7, valeur >= 7);
  digitalWrite(PIN_LED_8, valeur >= 8);
  digitalWrite(PIN_LED_9, valeur >= 9);
  digitalWrite(PIN_LED_10, valeur >= 10);
}

/* Affiche la valeur (valeur = n°LED allumée) */
void afficheBargraphe_inverse(byte valeur) {
  digitalWrite(PIN_LED_1, valeur < 1);
  digitalWrite(PIN_LED_2, valeur < 2);
  digitalWrite(PIN_LED_3, valeur < 3);
  digitalWrite(PIN_LED_4, valeur < 4);
  digitalWrite(PIN_LED_5, valeur < 5);
  digitalWrite(PIN_LED_6, valeur < 6);
  digitalWrite(PIN_LED_7, valeur < 7);
  digitalWrite(PIN_LED_8, valeur < 8);
  digitalWrite(PIN_LED_9, valeur < 9);
  digitalWrite(PIN_LED_10, valeur < 10);
}

L'extrait de code ci-dessus est disponible en téléchargement sur cette page (le lien de téléchargement en .zip contient le projet Arduino prêt à l'emploi).

Affichage binaire

Dans les deux chapitres précédents, nous avons fait un affichage décimal, nous allons à présent faire un affichage binaire.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
void loop() {
  static int valeur = 0;
  
  // Affiche la valeur
  afficheBargraphe(valeur);

  // Incrémente la valeur de 1, revient à 0 si > 1023
  if (++valeur == 1024) {
    valeur = 0; 
  }
  
  // Delai pour la démo
  delay(250);
}

La fonction loop() devra être modifiée pour boucler sur les valeurs entières entre 0 et 1023 (10 LEDs = 10 bits = 1024 valeurs possibles).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
void afficheBargraphe(int valeur) {
  digitalWrite(PIN_LED_1, bitRead(valeur, 0));
  digitalWrite(PIN_LED_2, bitRead(valeur, 1));
  digitalWrite(PIN_LED_3, bitRead(valeur, 2));
  digitalWrite(PIN_LED_4, bitRead(valeur, 3));
  digitalWrite(PIN_LED_5, bitRead(valeur, 4));
  digitalWrite(PIN_LED_6, bitRead(valeur, 5));
  digitalWrite(PIN_LED_7, bitRead(valeur, 6));
  digitalWrite(PIN_LED_8, bitRead(valeur, 7));
  digitalWrite(PIN_LED_9, bitRead(valeur, 8));
  digitalWrite(PIN_LED_10, bitRead(valeur, 9));
}

La condition dans la fonction afficheBargraphe() est remplacée par un appel à la fonction bitRead(). Cette fonction permet d'extraire la valeur d'un bit d'un nombre entier.

Le code complet avec commentaires :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
/**
 * Code d'exemple d'affichage binaire pour un bargraphe à LEDs.
 */

/* Les broches */
const byte PIN_LED_1 = 4;
const byte PIN_LED_2 = 5;
const byte PIN_LED_3 = 6;
const byte PIN_LED_4 = 7;
const byte PIN_LED_5 = 8;
const byte PIN_LED_6 = 9;
const byte PIN_LED_7 = 10;
const byte PIN_LED_8 = 11;
const byte PIN_LED_9 = 12;
const byte PIN_LED_10 = 13;

void setup() {
  
  /* Met les broches en sorties */
  pinMode(PIN_LED_1, OUTPUT);
  pinMode(PIN_LED_2, OUTPUT);
  pinMode(PIN_LED_3, OUTPUT);
  pinMode(PIN_LED_4, OUTPUT);
  pinMode(PIN_LED_5, OUTPUT);
  pinMode(PIN_LED_6, OUTPUT);
  pinMode(PIN_LED_7, OUTPUT);
  pinMode(PIN_LED_8, OUTPUT);
  pinMode(PIN_LED_9, OUTPUT);
  pinMode(PIN_LED_10, OUTPUT);
  
  /* Eteint les LEDs */
  afficheBargraphe(0);
}

void loop() {
  static int valeur = 0;
  
  // Affiche la valeur
  afficheBargraphe(valeur);

  // Incrémente la valeur de 1, revient à 0 si > 1023
  if (++valeur == 1024) {
    valeur = 0; 
  }
  
  // Delai pour la démo
  delay(250);
}

/* Affiche la valeur en binaire */
void afficheBargraphe(int valeur) {
  digitalWrite(PIN_LED_1, bitRead(valeur, 0));
  digitalWrite(PIN_LED_2, bitRead(valeur, 1));
  digitalWrite(PIN_LED_3, bitRead(valeur, 2));
  digitalWrite(PIN_LED_4, bitRead(valeur, 3));
  digitalWrite(PIN_LED_5, bitRead(valeur, 4));
  digitalWrite(PIN_LED_6, bitRead(valeur, 5));
  digitalWrite(PIN_LED_7, bitRead(valeur, 6));
  digitalWrite(PIN_LED_8, bitRead(valeur, 7));
  digitalWrite(PIN_LED_9, bitRead(valeur, 8));
  digitalWrite(PIN_LED_10, bitRead(valeur, 9));
}

L'extrait de code ci-dessus est disponible en téléchargement sur cette page (le lien de téléchargement en .zip contient le projet Arduino prêt à l'emploi).

Bonus : le retour de K2000

Un article sur les bargraphes à LEDs ne pourrait pas se conclure sans le classique effet de lumiére tiré de la série K2000 ;)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
void loop() {
  
  // Défile à droite
  for (byte i = 1; i < 10; ++i) {
    
    // Affiche la valeur
    afficheBargraphe(i);
    
    // Delai pour la démo
    delay(75);
  }
  
  // Défile à gauche
  for (byte i = 10; i > 1; --i) {
    
    // Affiche la valeur
    afficheBargraphe(i);
    
    // Delai pour la démo
    delay(75);
  }
}

Pour réaliser cet effet, il suffit de faire défiler un point lumineux de droite à gauche en boucle.

Dans notre cas, il suffit de reprendre le code d'affichage décimal et de remplacer le contenu de la fonction loop() par deux boucles : une de 1 à 9 et une de 10 à 2.

Ainsi on obtient l'effet de défilement : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, etc.

Le code complet avec commentaires :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
/**
 * Code d'exemple d'affichage K2000 pour un bargraphe à LEDs.
 */

/* Les broches */
const byte PIN_LED_1 = 4;
const byte PIN_LED_2 = 5;
const byte PIN_LED_3 = 6;
const byte PIN_LED_4 = 7;
const byte PIN_LED_5 = 8;
const byte PIN_LED_6 = 9;
const byte PIN_LED_7 = 10;
const byte PIN_LED_8 = 11;
const byte PIN_LED_9 = 12;
const byte PIN_LED_10 = 13;

void setup() {
  
  /* Met les broches en sorties */
  pinMode(PIN_LED_1, OUTPUT);
  pinMode(PIN_LED_2, OUTPUT);
  pinMode(PIN_LED_3, OUTPUT);
  pinMode(PIN_LED_4, OUTPUT);
  pinMode(PIN_LED_5, OUTPUT);
  pinMode(PIN_LED_6, OUTPUT);
  pinMode(PIN_LED_7, OUTPUT);
  pinMode(PIN_LED_8, OUTPUT);
  pinMode(PIN_LED_9, OUTPUT);
  pinMode(PIN_LED_10, OUTPUT);
  
  /* Eteint les LEDs */
  afficheBargraphe(0);
}

void loop() {
  
  // Défile à droite
  for (byte i = 1; i < 10; ++i) {
    
    // Affiche la valeur
    afficheBargraphe(i);
    
    // Delai pour la démo
    delay(75);
  }
  
  // Défile à gauche
  for (byte i = 10; i > 1; --i) {
    
    // Affiche la valeur
    afficheBargraphe(i);
    
    // Delai pour la démo
    delay(75);
  }
}

/* Affiche la valeur (valeur = n°LED allumée) */
void afficheBargraphe(byte valeur) {
  digitalWrite(PIN_LED_1, valeur == 1);
  digitalWrite(PIN_LED_2, valeur == 2);
  digitalWrite(PIN_LED_3, valeur == 3);
  digitalWrite(PIN_LED_4, valeur == 4);
  digitalWrite(PIN_LED_5, valeur == 5);
  digitalWrite(PIN_LED_6, valeur == 6);
  digitalWrite(PIN_LED_7, valeur == 7);
  digitalWrite(PIN_LED_8, valeur == 8);
  digitalWrite(PIN_LED_9, valeur == 9);
  digitalWrite(PIN_LED_10, valeur == 10);
}

L'extrait de code ci-dessus est disponible en téléchargement sur cette page (le lien de téléchargement en .zip contient le projet Arduino prêt à l'emploi).

Conclusion

Ce tutoriel est désormais terminé.

Si ce tutoriel vous a plu, n'hésitez pas à le commenter sur le forum, à le diffuser sur les réseaux sociaux et à soutenir le site si cela vous fait plaisir.