Communication longue portée avec LoRa SX1276 et ESP32

Dans ce tutoriel, vous apprendrez comment activer la communication longue portée en utilisant le module LoRa SX1276 et l’ESP32. Par exemple, si vous souhaitez recevoir des données de capteurs éloignés où il n’y a pas de couverture Wi-Fi, comme un capteur de température dans un coin de votre jardin, LoRa peut vous aider.

LoRa est une technologie sans fil conçue pour envoyer de petites quantités de données sur de longues distances en consommant très peu d’énergie. Elle fonctionne bien en espaces ouverts et peut atteindre plusieurs kilomètres, bien plus loin que le WiFi ou le Bluetooth. Cela la rend idéale pour les appareils alimentés par batterie comme les capteurs dans les fermes, les villes ou les zones isolées où le WiFi ou le Bluetooth classique ne peuvent pas atteindre ou consomment trop d’énergie.

Si vous connaissez déjà LoRa et souhaitez simplement savoir comment envoyer des données environnementales telles que la température et l’humidité, jetez un œil au Send Environmental Data with LoRa tutoriel.

Pièces requises

Voici les composants nécessaires pour ce tutoriel. J’ai utilisé une ancienne carte ESP32, qui est obsolète mais que vous pouvez encore trouver à très bas prix. Notez qu’il existe aussi une version avec un port USB-C. Cependant, n’importe quelle autre ESP32 fonctionnera très bien aussi. Il vous faudra simplement deux cartes et deux modules SX1276 – un pour l’envoi et un pour la réception.

Pour les modules transceivers LoRa SX1276, faites attention à la version que vous achetez ! Selon le pays, les fréquences autorisées pour ces modules diffèrent (link). C’est 868 MHz pour l’Europe, 915 MHz pour l’Amérique du Nord et 433 MHz pour l’Asie.

La description du module indique soit la fréquence, soit un numéro comme 868 ou 915 dans le nom. J’ai listé un module en 868 MHz, car je suis en Europe. Mais vous pouvez aussi trouver ce module pour la bande 915 MHz.

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Qu’est-ce que LoRa ?

Si vous réalisez des projets Arduino ou ESP32 et avez besoin d’envoyer des données sans fil sur de longues distances, LoRa (abréviation de Long Range) pourrait être exactement ce qu’il vous faut. Contrairement au WiFi et au Bluetooth, conçus pour une communication rapide à courte portée, LoRa est fait pour une transmission de données longue portée et basse consommation — parfait pour les capteurs et appareils distants qui doivent fonctionner des mois ou des années sur une petite batterie.

LoRa utilise un type spécial de modulation radio appelé Chirp Spread Spectrum (CSS). Cela le rend très résistant aux interférences et permet aux appareils de communiquer sur plusieurs kilomètres, même dans des environnements bruyants ou avec des obstacles comme des arbres et des bâtiments. LoRa fonctionne dans des bandes ISM frequency bands non licenciées — typiquement 868 MHz en Europe, 915 MHz en Amérique du Nord, et 433 MHz dans certains pays asiatiques. Ces fréquences varient selon la région mais ont toutes l’avantage d’être libres d’utilisation sans licence.

Le compromis avec LoRa est qu’il n’est pas conçu pour des débits élevés. Il est optimal pour de petites charges utiles, comme des relevés de capteurs ou des mises à jour d’état d’appareils. Les débits varient généralement de 0,3 kbps à 50 kbps, selon le spreading factor (SF), la bande passante et le coding rate choisis. La portée dépend aussi de ces réglages et de votre environnement : attendez-vous à 2–5 km en zones urbaines et 10–15 km en zones rurales ou en visibilité directe — parfois plus avec des antennes adaptées.

LoRa vs WiFi et Bluetooth

Le WiFi offre des vitesses rapides mais consomme beaucoup d’énergie et couvre généralement moins de 100 mètres. Le Bluetooth a une portée encore plus courte et est plus adapté aux appareils portables et personnels. Le tableau suivant compare les principales caractéristiques de LoRa avec le WiFi et le Bluetooth :

Caractéristique	LoRa	WiFi	Bluetooth
Consommation d’énergie	Très faible (μA en veille, ~10–50 mA en actif)	Élevée (~70–300 mA en actif)	Faible (~10–30 mA en actif)
Portée	2–15 km (rural), 0,5–5 km (urbain)	~50–100 mètres (intérieur), ~200 mètres (extérieur)	~10–100 mètres
Débit typique	0,3–50 kbps	Jusqu’à 100–600 Mbps (ESP32 : ~150 Mbps)	~1–3 Mbps (Classic), ~125–200 kbps (BLE)
Latence	Élevée (100 ms à plusieurs secondes)	Faible (~1–10 ms)	Faible (~3–50 ms BLE)

Dans cet article, nous allons explorer comment utiliser LoRa avec des cartes ESP32 et des modules comme le SX1276, et vous montrer comment commencer à envoyer des messages entre des appareils éloignés de plusieurs kilomètres — sans besoin de WiFi, de tours cellulaires, ni de beaucoup d’énergie.

Module LoRa SX1276

Le SX1276 est un module transceiver LoRa populaire fabriqué par Semtech, et c’est l’un des puces les plus utilisées pour la communication sans fil longue portée et basse consommation dans les projets DIY et IoT. Il supporte la modulation LoRa ainsi que les modes traditionnels FSK/OOK, ce qui le rend flexible pour une large gamme d’applications.

Le SX1276 est au cœur de nombreux modules LoRa, y compris le célèbre HopeRF RFM95W, très similaire au module que j’utilise dans ce tutoriel. La photo suivante montre le devant du module LoRa SX1276 avec la puce SX1276, le cristal quartz et le régulateur de tension.

Cette puce fonctionne dans la plage de 137 MHz à 1020 MHz, mais la plupart des modules qui l’utilisent sont configurés pour 433 MHz (Asie), 868 MHz (Europe) ou 915 MHz (Amérique du Nord), selon votre région. Au dos du module, on trouve généralement un petit tableau indiquant la fréquence de fonctionnement spécifique. La photo ci-dessous montre un module qui fonctionne dans la bande 915 MHz et pourrait donc être utilisé en Amérique du Nord :

Assurez-vous d’acheter et d’utiliser un module avec la fréquence de transmission correcte pour votre pays. Sinon, vous pourriez avoir des problèmes avec l’organisme qui régule les transmissions radio dans votre pays !

Le module peut communiquer sur des distances de 2 à plus de 15 kilomètres, selon la qualité de l’antenne, le terrain et les réglages. Le SX1276 supporte des débits de 0,018 kbps à 37,5 kbps en mode LoRa et jusqu’à 300 kbps en mode FSK, et offre un contrôle précis sur des paramètres comme la bande passante, le facteur d’étalement et le taux de codage, vous permettant d’optimiser la portée, la consommation d’énergie ou la fiabilité.

Détails techniques du SX1276

Voici les principales caractéristiques du module LoRa SX1276 :

• Tension de fonctionnement : 1,8 – 3,7V
• Bande de fréquence : 868 MHz / 915 MHz
• Puissance de sortie : 20 dBm / 100 mW
• Sensibilité de réception : -139 dBm @146B
• Modulation : LORA / GFSK
• Interface de données : SPI 4 fils
• Dimensions du module : 16*16 mm, espacement des broches 2,0 mm
• Courant en émission : 120 mA @ 100 mW / 3,3 V
• Courant en réception : 10 mA / 3,3 V
• Courant en veille : 0,2 μA

Pour plus de détails, consultez la fiche technique liée ci-dessous :

Brochage du module LoRa SX1276

Le module LoRa SX1276 possède 16 broches. Une pour l’antenne (ANT), une pour l’alimentation (VCC), plusieurs broches de masse (GND), les broches pour SPI (RST, NSS, SCK, MOSI, MISO) et six broches configurables Digital IO (DIO) :

Notez que le SX1276 utilise une logique 3,3 V et ne peut donc pas être connecté directement à un Arduino UNO, par exemple, qui fonctionne en logique 5 V. Si vous souhaitez utiliser une carte Arduino au lieu d’un ESP32, vous devez soit utiliser un logic level shifter soit un Arduino that uses 3.3V logic.

Rendre le module SX1276 compatible breadboard

Les trous de broches du module LoRa SX1276 sont espacés de 2 mm, ce qui signifie que si vous soudez des broches, elles ne correspondent pas à l’espacement standard de 2,54 mm d’une breadboard. Cependant, comme nous n’avons pas besoin de toutes les broches du module, vous pouvez plier les broches d’un connecteur standard 2,54 mm pour que cela fonctionne.

La photo ci-dessous montre les broches GND, DIO3, DIO4, VCC et DIO0 connectées à un connecteur 2,54 mm. J’ai plié les broches en haut du connecteur pour correspondre à l’espacement plus petit de 2 mm des trous du module :

Notez que DIO1 et DIO2 ne sont pas connectés. Vous pourriez aussi ne pas connecter DIO3 et DIO4, car ils ne sont pas nécessaires, mais il est plus rapide de souder le connecteur complet que des broches individuelles.

De l’autre côté du module, on fait la même chose. On connecte RST, NSS, SCK, MOSI et MISO et on laisse les deux broches GND et DIO5 non connectées :

Avec cette astuce simple, vous pouvez faire tenir le module LoRa SX1276 sur une breadboard. La photo ci-dessous montre le dessous du module avec les deux connecteurs soudés et l’antenne soudée :

Il faut juste faire attention lors du câblage car les étiquettes sur la sérigraphie et les broches sont légèrement décalées.

Notez aussi que votre antenne peut avoir une apparence différente (plus longue, juste un fil) selon le module et sa fréquence.

Connexion du SX1276 à l’ESP32

Le SX1276 est contrôlé via une interface SPI. Pour le connecter à un ESP32, vous devez faire les connexions suivantes :

SX1276	ESP32
MOSI	23
MSIO	19
SCK	18
RST	17
NSS	5
DIO0	4
GND	GND
VCC	3,3 V

Assurez-vous de connecter VCC à la sortie 3,3 V de votre ESP32. Aussi, si vous utilisez la version compatible breadboard du module, souvenez-vous que seule la broche GND à côté de l’antenne ANT est connectée — les deux autres ne le sont pas ! Enfin, DIO0 doit être connecté à une broche d’interruption de l’ESP32. La photo ci-dessous montre le schéma complet de câblage :

Si vous utilisez une autre carte ESP32, les broches pour le SPI matériel, sur lesquelles repose ce câblage, peuvent être différentes. Si vous ne savez pas quelles broches utiliser sur votre carte, consultez le Find I2C and SPI default pins tutoriel.

La photo suivante montre à quoi cela ressemble sur ma breadboard, une fois complètement câblé :

Enfin, notez que nous n’allons en fait pas utiliser DIO0 dans le code suivant. Vous pouvez donc omettre cette connexion. Cependant, DIO0 peut servir à signaler l’arrivée de données via un gestionnaire d’interruption, ce qui peut être utile dans votre application.

Code pour la communication LoRa

Dans cette section, nous écrivons le code pour l’émetteur et le récepteur LoRa. Le matériel et le câblage sont identiques (un ESP32 avec un SX1276 connecté) mais le code est différent.

L’émetteur envoie une valeur de compteur incrémentée toutes les deux secondes, tandis que le récepteur attend le message de l’émetteur et affiche la valeur du compteur dans le moniteur série à la réception. L’émetteur fait aussi clignoter la LED intégrée lors de l’envoi, tandis que le récepteur fait clignoter sa LED à la réception.

Commençons par le code de l’émetteur. Jetez un coup d’œil rapide au code complet, puis nous en détaillerons les parties.

Émetteur

#include <SPI.h>
#include <LoRa.h>

// WEMOS LOLIN32 Lite
// MOSI ->  23
// MISO ->  19
// SCK  ->  18
#define SS 5
#define RST 17
#define DIO0 4

#define LED_BUILTIN 22

void setup() {
  Serial.begin(115200);

  pinMode(LED_BUILTIN, OUTPUT);
  LoRa.setPins(SS, RST, DIO0);
  
  // 433E6: Asia, 868E6: Europe, 915E6: North America
  while (!LoRa.begin(868E6)) {  
    Serial.println(".");
    delay(500);
  }
  LoRa.setSyncWord(0x34);          // 0-0xFF sync word to match the receiver
  LoRa.setSpreadingFactor(12);     // (6-12) higher value increases range but decreases data rate
  LoRa.setSignalBandwidth(125E3);  // lower value increases range but decreases data rate
  LoRa.setCodingRate4(8);          // higher value increases range but decreases data rate
  LoRa.enableCrc();                // improves data reliability
}

void loop() {
  static int counter = 0;

  Serial.print("Sending counter: ");
  Serial.println(++counter);

  digitalWrite(LED_BUILTIN, HIGH);
  LoRa.beginPacket();
  LoRa.print("Counter=");
  LoRa.print(counter);
  LoRa.endPacket();
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);  
}

D’abord, nous incluons les deux bibliothèques nécessaires :

#include <SPI.h>
#include <LoRa.h>

La bibliothèque SPI.h permet à l’ESP32 de communiquer avec le transceiver LoRa via SPI (Serial Peripheral Interface). Tandis que la bibliothèque LoRa.h nous offre une interface simple pour envoyer et recevoir des paquets LoRa. Vous pouvez installer la bibliothèque LoRa library by Sandeep Mistry via le Library Manager dans l’IDE Arduino. La photo ci-dessous montre une installation réussie de la bibliothèque :

Ensuite, nous définissons les broches GPIO connectées aux lignes de contrôle du module pour l’interface SPI :

#define SS 5
#define RST 17
#define DIO0 4
#define LED_BUILTIN 22

SS, RST, et DIO0 sont nécessaires pour le module LoRa. Nous définissons aussi LED_BUILTIN pour contrôler la LED intégrée, qui nous donne un retour visuel lors de la transmission. Sur le WEMOS LOLIN32 Lite, la LED intégrée est connectée à la broche 22.

setup

Passons maintenant à la fonction setup(). Cette partie s’exécute une fois au démarrage ou au reset de la carte :

void setup() {
  Serial.begin(115200);

  pinMode(LED_BUILTIN, OUTPUT);
  LoRa.setPins(SS, RST, DIO0);

Nous commençons par initialiser le moniteur série pour le débogage. Puis, nous configurons la broche de la LED en sortie. Ensuite, nous utilisons LoRa.setPins() pour indiquer à la bibliothèque quelles broches sont connectées au module LoRa.

Puis nous initialisons la radio LoRa à 868 MHz, utilisée en Europe. N’oubliez pas d’utiliser la fréquence spécifique autorisée pour les transmissions LoRa dans votre pays !

  while (!LoRa.begin(868E6)) {  
    Serial.println(".");
    delay(500);
  }

Si le module LoRa ne démarre pas, nous réessayons en boucle, en affichant un point à chaque tentative. Cela aide à diagnostiquer les problèmes de démarrage comme un mauvais câblage.

Une fois le module prêt, nous le configurons pour une communication longue portée fiable :

  LoRa.setSyncWord(0x34);
  LoRa.setSpreadingFactor(12);
  LoRa.setSignalBandwidth(125E3);
  LoRa.setCodingRate4(8);
  LoRa.enableCrc();
}

Voici ce que fait chaque réglage :

• setSyncWord(0x34) garantit que seuls les appareils avec le même mot de synchronisation peuvent communiquer entre eux. C’est comme un identifiant réseau simple.
• setSpreadingFactor(12) augmente la portée et la fiabilité en étalant davantage le signal. Les valeurs vont de 6 à 12 — plus c’est élevé, meilleure est la portée mais plus le débit est lent.
• setSignalBandwidth(125E3) règle la bande passante radio à 125 kHz. Une bande passante plus étroite augmente la portée et diminue le débit.
• setCodingRate4(8) renforce la correction d’erreur, aidant les données à arriver intactes même sur des liens bruyants.
• enableCrc() ajoute une somme de contrôle à chaque paquet pour détecter les erreurs de transmission.

loop

Passons maintenant à la fonction loop(), qui s’exécute en continu :

void loop() {
  static int counter = 0;

  Serial.print("Sending counter: ");
  Serial.println(++counter);

Nous utilisons un static int pour suivre combien de paquets ont été envoyés. Ensuite, nous affichons cette valeur dans le moniteur série à chaque fois pour le débogage.

Avant d’envoyer un paquet, nous allumons la LED pour indiquer la transmission :

  digitalWrite(LED_BUILTIN, HIGH);

Puis nous construisons le paquet LoRa (=message) :

  LoRa.beginPacket();
  LoRa.print("Counter=");
  LoRa.print(counter);
  LoRa.endPacket();

Cela crée un paquet avec le contenu "Counter=1", "Counter=2", etc. Le récepteur recevra cette chaîne et pourra décider quoi en faire.

Après l’envoi, nous éteignons la LED et attendons une seconde avant la prochaine transmission :

  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);  
}

Chaque cycle dure environ deux secondes — une pour la transmission et une pour la pause. Vous pouvez ajuster le délai selon vos besoins.

Et voilà ! Ce sketch envoie des paquets LoRa toutes les deux secondes tout en faisant clignoter une LED pour montrer l’activité. Sur le moniteur série, vous devriez voir un message affiché à chaque envoi de paquet :

Dans la section suivante, nous écrivons le code correspondant pour le récepteur.

Récepteur

Le récepteur attend la transmission de l’émetteur et les affiche sur le moniteur série. Voici le code complet :

#include <SPI.h>
#include <LoRa.h>

// WEMOS LOLIN32 Lite
// MOSI ->  23
// MISO ->  19
// SCK  ->  18
#define SS 5
#define RST 17
#define DIO0 4

#define LED_BUILTIN 22

void setup() {
  Serial.begin(115200);

  pinMode(LED_BUILTIN, OUTPUT);
  LoRa.setPins(SS, RST, DIO0);

  // 433E6: Asia, 868E6: Europe, 915E6: North America
  while (!LoRa.begin(868E6)) {
    Serial.println(".");
    delay(500);
  }
  LoRa.setSyncWord(0x34);          // 0-0xFF sync word to match the receiver
  LoRa.setSpreadingFactor(12);     // (6-12) higher value increases range but decreases data rate
  LoRa.setSignalBandwidth(125E3);  // lower value increases range but decreases data rate
  LoRa.setCodingRate4(8);          // higher value increases range but decreases data rate
  LoRa.enableCrc();                // improves data reliability
}

void loop() {
  if (LoRa.parsePacket()) {
    digitalWrite(LED_BUILTIN, LOW);
    while (LoRa.available()) {
      Serial.print((char)LoRa.read());
    }
    Serial.printf("    (%d)\n", LoRa.packetRssi());
    delay(100);
    digitalWrite(LED_BUILTIN, HIGH);
  }
}

Comme avant, nous commençons par inclure les mêmes deux bibliothèques essentielles :

#include <SPI.h>
#include <LoRa.h>

C’est identique à l’émetteur. SPI.h permet la communication via le bus SPI, et LoRa.h nous donne toutes les fonctions nécessaires pour recevoir des paquets.

Ensuite, nous définissons les mêmes correspondances de broches pour le WEMOS LOLIN32 Lite :

#define SS 5
#define RST 17
#define DIO0 4

#define LED_BUILTIN 22

Cela configure la communication avec le module LoRa, et encore une fois, nous assignons la broche 22 pour la LED intégrée. Le matériel et la majeure partie du code sont identiques pour l’émetteur et le récepteur, mais vous pourriez utiliser des configurations matérielles différentes, par exemple d’autres microcontrôleurs ou broches.

setup

Passons maintenant à la fonction setup(), qui ressemble presque à celle de l’émetteur :

void setup() {
  Serial.begin(115200);

  pinMode(LED_BUILTIN, OUTPUT);
  LoRa.setPins(SS, RST, DIO0);

Nous ouvrons la connexion série à 115200 bauds pour pouvoir afficher les messages entrants. Puis nous configurons la broche LED en sortie et assignons les broches de contrôle LoRa avec LoRa.setPins().

Comme pour l’émetteur, nous initialisons LoRa à la fréquence 868 MHz, utilisée en Europe :

  while (!LoRa.begin(868E6)) {
    Serial.println(".");
    delay(500);
  }

Évidemment, l’émetteur et le récepteur doivent fonctionner sur la même fréquence. Si le module ne s’initialise pas correctement, nous réessayons toutes les 500 millisecondes, en affichant des points dans le moniteur série pour indiquer l’état.

Ensuite, vient la même configuration LoRa utilisée pour l’émetteur :

  LoRa.setSyncWord(0x34);          
  LoRa.setSpreadingFactor(12);     
  LoRa.setSignalBandwidth(125E3);  
  LoRa.setCodingRate4(8);          
  LoRa.enableCrc();                
}

En reproduisant la configuration de l’émetteur, nous garantissons que les deux appareils peuvent se comprendre. Si un seul paramètre diffère — comme le mot de synchronisation ou la bande passante — le récepteur ne pourra pas décoder le paquet.

loop

Regardons maintenant le cœur du récepteur, la fonction loop() :

void loop() {
  if (LoRa.parsePacket()) {

Ici, LoRa.parsePacket() vérifie si un paquet est arrivé. Si rien n’est reçu, la fonction retourne 0 et le reste de la boucle est ignoré.

Quand un paquet est reçu, nous allumons immédiatement la LED pour signaler l’événement.

    digitalWrite(LED_BUILTIN, LOW);

Notez que la logique de la LED intégrée est inversée. LOW signifie que la LED est allumée et HIGH qu’elle est éteinte.

Ensuite, nous lisons le contenu du paquet octet par octet et l’affichons en caractères dans le moniteur série :

    while (LoRa.available()) {
      Serial.print((char)LoRa.read());
    }

C’est là que les messages "Counter=1", "Counter=2" envoyés par l’émetteur apparaissent.LoRa.available() vérifie s’il y a plus d’octets disponibles, et LoRa.read() récupère chaque octet du paquet. Nous le convertissons en char pour qu’il s’affiche en texte lisible.

Puis nous affichons le RSSI (Received Signal Strength Indicator), qui indique la puissance du signal :

    Serial.printf("    (%d)\n", LoRa.packetRssi());

C’est utile pour déboguer la portée radio. Plus le nombre est négatif, plus le signal est faible. Par exemple, -45 dB est fort, tandis que -120 dB est presque illisible.

Enfin, nous faisons une courte pause pour voir la LED allumée, puis nous l’éteignons, indiquant que le code attend maintenant le prochain paquet.

    delay(100);
    digitalWrite(LED_BUILTIN, HIGH);
  }
}

Avec ce code, votre récepteur ESP32 LoRa écoute les messages comme "Counter=3" envoyés par votre émetteur. Vous obtenez une confirmation visuelle via la LED et des mises à jour en direct dans le moniteur série avec la force du signal entre parenthèses :

Et voilà. Vous pouvez maintenant envoyer des données de capteurs situés à plusieurs kilomètres, et grâce à la faible consommation de LoRa, ces capteurs peuvent fonctionner longtemps sur batterie.

Conclusions

Dans ce tutoriel, vous avez appris comment réaliser une communication longue portée avec le module LoRa SX1276 et l’ESP32.

Si vous souhaitez utiliser un Arduino au lieu d’un ESP32, vous devez soit utiliser un convertisseur de niveau logique, soit un Arduino fonctionnant en 3,3 volts, car le module SX1276 ne fonctionne pas en 5 V ! Consultez le Interface Arduino Uno with ST7735 TFT using Level Shifter tutoriel si vous voulez apprendre à utiliser un convertisseur de niveau logique.

Une application typique de LoRa est l’envoi de données de température, d’humidité et autres données environnementales sur de longues distances. Voir notre Send Environmental Data with LoRa tutoriel, si c’est ce que vous souhaitez faire.

Pour une communication rapide et simple à courte portée, le Bluetooth est plus adapté. Vous trouverez des informations à ce sujet dans les ESP32 And Bluetooth Module- HC-05 et How To Connect ESP32 Bluetooth With A Smartphone tutoriels.

Et si vous voulez transmettre des informations via Internet, le ESP32 send Telegram Message peut être utile.

LoRa est idéal pour transmettre entre quelques capteurs. Mais si vous avez beaucoup de capteurs à gérer et souhaitez envoyer les mesures sur Internet, LoRaWAN est la solution. Consultez le LoRaWAN with Thinknode G1 Gateway tutoriel pour plus d’informations sur ce sujet.

Enfin, je vous recommande de parcourir les informations sur https://www.thethingsnetwork.org pour en apprendre davantage sur LoRa et le code d’exemple du LoRa library. Dans cet article, nous n’avons fait qu’effleurer le sujet.

Si vous avez des questions, n’hésitez pas à les poser dans la section commentaires.

Bon bricolage ; )