Code de recherche

ESP32 Project: Build a Secure, Long-Range LoRa Chat Device Heltec WiFi LoRa 32 on N33

Cette leçon fait partie de: Introduction au WiFi LoRa
Toutes les leçons
Video thumbnail for Long range Private, off-grid communication using Heltec WiFi LoRa 32 on N33
Regarder sur YouTube

ESP32 Project: Build a Secure, Long-Range LoRa Chat Device Heltec WiFi LoRa 32 on N33

Build a Secure, Off-Grid LoRa Messenger with a Custom Keyboard

In a world that relies on constant connectivity, what do you do when the Wi-Fi is down, the power is out, and cellular service is gone? This project tackles that exact problem by creating a completely self-sufficient, off-grid communication device that allows you to send and receive secure, private text messages over distances of up to 13 miles (21km) or even more.

This device is a practical tool for emergency preparedness, outdoor adventures like hiking, or simply for anyone interested in building a robust, private communication network that they control. Using a powerful Heltec WiFi LoRa 32 V3 module packed inside a durable Meshnology N33 case with a long-lasting 3000mAh battery, this project is built for real-world use. The most unique feature is its keyboard—a simple rotary encoder that provides an intuitive and reliable way to type messages anywhere, anytime.

How It Works: The Magic of LoRa and a Rotary Encoder

The project combines three key concepts to create a functional messenger:

  • LoRa Radio: LoRa (Long Range) is a radio technology that allows for communication over vast distances with very little power. Unlike Wi-Fi or cellular, it operates on license-free radio frequencies, meaning there are no SIM cards or monthly fees involved. Our device operates as a full transceiver, meaning it can both send and receive messages. When idle, it listens for incoming packets. After sending or receiving a message, it puts the radio to sleep momentarily to conserve power before returning to listening mode.
  • Rotary Encoder Keyboard: Instead of a bulky or power-hungry keyboard, we use a simple rotary encoder for text input. Rotating the knob cycles through a complete character set (A-Z, a-z, numbers, and symbols). The interface is surprisingly fast and responsive, allowing you to easily compose messages. The encoder's built-in push-button has three functions:
    • Short Press (Click): Adds the selected character to your message.
    • Long Press (Hold): Adds a space, like a spacebar.
    • Double-Click: Acts as a backspace to delete the last character.
  • Transceiver & Display Logic: The device has two main modes: "Compose" and "Read". You type your message in Compose mode. When a new message arrives, a notification appears on the screen (>> NEW MSG <<). You can then press the onboard User Button (on the Heltec board) to switch to Read mode and view the message. Another press switches you back to Compose mode to type your reply. All messages are secured using AES encryption, ensuring your conversations remain private.

Components and Parts List

To build this project, you will need the following components. As mentioned in the video, purchasing through affiliate links is a great way to support creators.

  • Heltec WiFi LoRa 32 V3 Module
  • Meshtastic N33 Case with 3000mAh Battery
  • 915MHz or region-appropriate LoRa Antenna
  • Rotary Encoder Module (5-pin with VCC, GND, CLK, DT, SW)
  • Optional (for audio alerts):
    • 5V Active Buzzer
    • 2N2222 NPN Transistor
    • 1kΩ Resistor
  • Pin Headers and Jumper Wires
  • Soldering Iron and accessories

Setting Up Your Arduino IDE

Before you can upload the code, you need to configure the Arduino IDE with the correct boards and libraries. This process is detailed in the video starting around 05:38.

Step 1: Install the ESP32 Boards

If you haven't already, you need to add support for ESP32 microcontrollers.

  1. Open the Arduino IDE, go to File > Preferences.
  2. In the "Additional boards manager URLs" field, add the following URL: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
  3. Go to Tools > Board > Boards Manager....
  4. Search for esp32 and install the package by Espressif Systems.

Step 2: Add the Heltec ESP32 Board Support

  1. In File > Preferences, add the Heltec JSON URL on a new line in the "Additional boards manager URLs" box (the video shows how to do this at 06:27): https://github.com/Heltec-Aaron-Lee/WiFi_Kit_series/releases/download/0.0.7/package_heltec_esp32_index.json
  2. Go back to Tools > Board > Boards Manager....
  3. Search for Heltec ESP32 and install the package.

Step 3: Install Required Libraries from Library Manager

Using the Arduino Library Manager (Sketch > Include Library > Manage Libraries...), search for and install the following libraries:

  1. Ai Esp32 Rotary Encoder: The specific library used for our responsive keyboard.
  2. Heltec ESP32 Dev-Boards: The official library for the Heltec hardware.
  3. Adafruit GFX Library: A dependency for the OLED display.

Step 4: Install the Robojax Helper Library from .ZIP

As explained in the video at 18:53, a custom helper library is used for this project. You must install it from a .zip file.

  1. Download the "Robojax HealthTech Lora 32" .zip library from the link provided on the resources page.
  2. In the Arduino IDE, click on Sketch > Include Library > Add .ZIP Library....
  3. Navigate to where you saved the downloaded .zip file, select it, and click "Open".
  4. The library will be installed and ready to use.

After installing everything, make sure you select the correct board from the menu: Tools > Board > Heltec ESP32 Arduino > Heltec WiFi LoRa 32 V3.

Wiring the Components

You will need to solder pin headers to your Heltec board to connect the rotary encoder. As shown in the video (11:25), careful planning is needed to ensure the pins are accessible once the board is in its case.

Helte_Wifi_LoRA_Rotary_Encoder

Diagram 1: Core Messenger (Rotary Encoder Only)

Connect the 5 pins from the rotary encoder module to the Heltec board as follows:

  • GND on encoder → GND on Heltec board
  • VCC on encoder → 3.3V on Heltec board
  • SW (Switch) → GPIO 4
  • DT (Data/Pin B) → GPIO 6
  • CLK (Clock/Pin A) → GPIO 5
Helte_Wifi_LoRA_Rotary_Encoder with buzzer

Diagram 2: Adding an Audible Alert (Buzzer Circuit)

To get an audible beep when a new message arrives, you can add a simple transistor circuit. This is necessary because the ESP32's pins cannot provide enough current to drive a buzzer directly.

  • Connect GPIO 40 from the Heltec board to one end of the 1kΩ resistor.
  • Connect the other end of the resistor to the Base pin of the 2N2222 transistor.
  • Connect the Emitter pin of the transistor to GND.
  • Connect the positive (+) leg of the 5V buzzer to the 3.3V pin on the Heltec board.
  • Connect the negative (-) leg of the buzzer to the Collector pin of the transistor.

Understanding and Customizing the Code

The provided code is ready to upload, but there are a few key settings you should be aware of so you can customize the project. These definitions are at the top of the code.


// Defines for physical pin connections
#define ROTARY_ENCODER_A_PIN 5 //pin A of rotary encoder
#define ROTARY_ENCODER_B_PIN 6 //pin B of rotary encoder
#define ROTARY_ENCODER_BUTTON_PIN 4 //switch pin of rotary encoder
#define BUZZER_PIN 40 //the buzzer pin or relay to be triggered
const bool DEBUG = false;

// Defines for LoRa and Security settings
#define RF_FREQUENCY 915432000 //operating frequency of LoRa
#define TX_OUTPUT_POWER 2 //output power should be between 2 to 21 in dBm. 
const char *userKey = "xxxBg^Tr%43232";//security key for private communication
  • ROTARY_ENCODER_...: These pins define where you connected your rotary encoder. Make sure these numbers match your wiring from the diagrams above.
  • BUZZER_PIN: This defines which pin will trigger the buzzer circuit.
  • RF_FREQUENCY: This is the LoRa operating frequency in Hertz. The value 915432000 (915 MHz) is standard for North America. You must change this value according to your region (e.g., 868MHz for Europe, 433MHz for Asia). All devices that want to communicate must use the same frequency.
  • TX_OUTPUT_POWER: This is the transmission power in dBm. It can range from 2 to 20. A lower number like 2 is perfect for short-range testing and saves a significant amount of battery. For maximum range, you can increase this value, but be aware that higher power drains the battery much faster.
  • userKey: This is your private encryption key. It can be any combination of characters. All devices must have the exact same key to decrypt each other's messages. Change this to your own unique and secret password.

Get the Code

The complete and final Arduino code for this project, as referenced in the video, is available for download on this page.

Video Chapters

  • 00:00 - Introduction
  • 00:56 - Project Outline
  • 01:29 - Components Overview
  • 05:25 - Unboxing and Hardware Assembly
  • 11:19 - Case Modification for External Wires
  • 15:06 - Wiring Guide
  • 15:38 - Arduino IDE and Library Setup
  • 20:21 - Code Settings Explained
  • 21:38 - How to Use the Rotary Encoder to Chat
  • 24:26 - Live Range Test
Veuillez consulter cette page en anglais si le code n'est pas visible. Nous sommes désolés pour le désagrément.
785-Secure, Long-Range LoRa Chat Device Heltec WiFi LoRa 32
Langue: C++
/*
 * Projet ESP32 : Construire un appareil de chat LoRa sécurisé à longue portée Heltec WiFi LoRa 32
 * 
 * Fichier : Heltec_ESP32_LoRa_V3_chat_TX_RX.ino
 * écrit le 29 juin 2025 par Ahmad Shamshiri www.Roboajx.com
 * Veuillez regarder la vidéo tutorielle à : https://youtu.be/IsOSvrF60J4
 * Page des ressources pour cette vidéo : https://robojax.com/RJT642
 * 
 * =====================================================================
 * DESCRIPTION DU CODE ARDUINO : TRANSM_RECEUR CLAVIER LoRa SÉCURISÉ (système de chat)
 * =====================================================================
 * 
 * COMPOSANTS MATÉRIELS :
 * -------------------
 * - Contrôleur principal : Heltec WiFi LoRa 32 V3
 * - Enveloppe : Étui Meshnology N33 avec batterie 3000mAh
 * - Entrée : Codeur rotatif avec bouton-poussoir
 * - Retour : Écran OLED intégré
 * 
 * FONCTIONNALITÉ DU SYSTÈME :
 * -------------------
 * NOUVEAUX COMMANDES :
 * - Bouton rotatif : Sélectionner un caractère.
 * - Pression courte (clic) : Ajouter le caractère sélectionné.
 * - Pression longue (maintenir) : Insérer un espace (comme une barre d'espace).
 * - Double clic : Effacer.
 * 
 * [2] TRANSMISSION WIRELESS SÉCURISÉE :
 * - Tous les messages sont chiffrés avant la transmission LoRa
 * - Commande de position d'accueil transmise sous forme de paquet sécurisé spécial
 * - Utilise la bande LoRa 433MHz/915MHZ pour une communication fiable
 * 
 * [3] GESTION DE L'ÉNERGIE :
 * - Optimisé pour le fonctionnement sur batterie (3000mAh)
 * - Modes basse consommation entre les transmissions
 * 
 * POUR DES INSTRUCTIONS D'INSTALLATION COMPLÈTES :
 * Veuillez regarder la vidéo tutorielle à : https://youtu.be/IsOSvrF60J4
 * Page des ressources pour cette vidéo : https://robojax.com/RJT642
 * =====================================================================
 * 
 * AVERTISSEMENT :
 * Ce code est fourni "TEL QUEL" sans garantie d'aucune sorte. L'auteur
 * ne pourra en aucun cas être tenu responsable des dommages résultant de l'utilisation de ce code.
 * 
 * LICENCE :
 * Ce travail est sous licence GNU General Public License v3.0
 * Des permissions au-delà de la portée de cette licence peuvent être disponibles sur Robojax.com
 * 
 * CONDITIONS DE PARTAGE :
 * Vous êtes libre de partager, copier et modifier ce code à des fins non commerciales
 * À CONDITION que :
 * 1. Vous conserviez l'intégralité de ce bloc de commentaires intact avec le code original
 * 2. Vous incluiez le lien original de Robojax.com
 * 3. Vous conserviez le lien de la vidéo tutorielle YouTube (le cas échéant)
 * 4. Vous indiquiez clairement les modifications apportées
 * 
 * /
 * // Bibliothèques de base Heltec et d'affichage
 */
#include <Wire.h>
#include "HT_SSD1306Wire.h"
#include "WiFi.h"

 // Bibliothèques LoRa et de sécurité
#include "LoRaWan_APP.h"
#include "mbedtls/aes.h"
#include <cstring>

 // La bibliothèque d'encodeurs rotatifs approuvée par les utilisateurs
#include "AiEsp32RotaryEncoder.h"

 // --- DÉFINITIONS ET CONFIGURATION DES PIN ---
static SSD1306Wire  display(0x3c, 500000, SDA_OLED, SCL_OLED, GEOMETRY_128_64, RST_OLED);

#define ROTARY_ENCODER_A_PIN 5 // broche A de l'encodeur rotatif
#define ROTARY_ENCODER_B_PIN 6 // broche B de l'encodeur rotatif
#define ROTARY_ENCODER_BUTTON_PIN 4 // broche de commutation de l'encodeur rotatif

#define RF_FREQUENCY 915432000 // fréquence de fonctionnement de LoRa
#define TX_OUTPUT_POWER 20 // la puissance de sortie doit être comprise entre 2 et 21 en dBm.
const char *userKey = "wahJ8uy$gt~_3r"; // clé de sécurité pour une communication privée

#define ROTARY_ENCODER_VCC_PIN -1
#define ROTARY_ENCODER_STEPS 4

 // --- PARAMÈTRES LORA ---
#define LORA_BANDWIDTH 0
#define LORA_SPREADING_FACTOR 7
#define LORA_CODINGRATE 1
#define LORA_PREAMBLE_LENGTH 8
#define LORA_SYMBOL_TIMEOUT 0
#define LORA_FIX_LENGTH_PAYLOAD_ON false
#define LORA_IQ_INVERSION_ON false
#define BUFFER_SIZE 256

#define USER_BUTTON_PIN 0
 // --- VARIABLES MONDIALES & ÉTAT ---
enum AppState { COMPOSING, READING };
AppState currentState = COMPOSING;
String messageToCompose = "";
String lastReceivedMessage = "No messages yet.";
bool hasUnreadMessage = false;
volatile bool newPacketAvailable = false;
char rxpacket[BUFFER_SIZE];
AiEsp32RotaryEncoder rotaryEncoder = AiEsp32RotaryEncoder(ROTARY_ENCODER_A_PIN, ROTARY_ENCODER_B_PIN, ROTARY_ENCODER_BUTTON_PIN, ROTARY_ENCODER_VCC_PIN, ROTARY_ENCODER_STEPS);
const char* charset = " ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.,!?>";
char selectedChar;
static RadioEvents_t RadioEvents;
bool lora_idle = true;

mbedtls_aes_context aes;
unsigned long shortPressAfterMiliseconds = 50;
unsigned long longPressAfterMiliseconds = 1000;
unsigned long doubleClickTimeout = 400;
static unsigned long buttonDownTime = 0;
static unsigned long buttonUpTime = 0;
static bool buttonWasDown = false;
static bool doubleClickWaiting = false;

 // --- PROTOTYPES DE FONCTION ---
void OnTxDone(void);
void OnTxTimeout(void);
void OnRxDone(uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr);
void encryptAES(uint8_t *data, const char *key);
void decryptAES(uint8_t *data, const char *key);
void processKey(const char *userKey, uint8_t *processedKey, size_t keySize);
void updateDisplay();
void sendData();
void VextON(void);
void processButton();

 // --- ROUTINES DE SERVICE D'INTERRUPTION ---
void IRAM_ATTR readEncoderISR() {
  rotaryEncoder.readEncoder_ISR();
}

 // --- ACTIONS DU GESTIONNAIRE DE BOUTONS ---
void on_button_short_click() {
  if (currentState != COMPOSING) return;
  if (selectedChar == '>') {
      sendData();
  } else {
    messageToCompose += selectedChar;
  }
  updateDisplay();
}
void on_button_long_click() {
  if (currentState != COMPOSING) return;
  messageToCompose += " ";
  updateDisplay();
}
void on_button_double_click() {
  if (currentState != COMPOSING) return;
  if (messageToCompose.length() > 0) {
    messageToCompose.remove(messageToCompose.length() - 1);
  }
  updateDisplay();
}

 // --- CONFIGURATION ---
void setup() {
  Serial.begin(115200);
  Serial.println("LoRa Keyboard Transceiver - Definitive Version");

  VextON();
  delay(100);
  Mcu.begin(HELTEC_BOARD,SLOW_CLK_TPYE);
  WiFi.mode(WIFI_OFF);
  btStop();

  display.init();
  display.setFont(ArialMT_Plain_10);

  rotaryEncoder.begin();
  rotaryEncoder.setup(readEncoderISR);
  rotaryEncoder.setBoundaries(0, strlen(charset) - 1, true);
  rotaryEncoder.disableAcceleration();

  pinMode(USER_BUTTON_PIN, INPUT_PULLUP);

  RadioEvents.TxDone = OnTxDone;
  RadioEvents.TxTimeout = OnTxTimeout;
  RadioEvents.RxDone = OnRxDone;
  Radio.Init(&RadioEvents);
  Radio.SetChannel(RF_FREQUENCY);

  Radio.SetRxConfig(MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,
                   LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,
                   LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON,
                   0, true, 0, 0, LORA_IQ_INVERSION_ON, true);

  updateDisplay();
}

 // --- BOUCLE PRINCIPALE ---
void loop() {
  if(lora_idle) {
    lora_idle = false;
    Serial.println("Entering RX mode...");
    Radio.Rx(0);
  }
  Radio.IrqProcess();

  if (newPacketAvailable) {
    newPacketAvailable = false;
    hasUnreadMessage = true;
    lastReceivedMessage = String(rxpacket);
    Serial.print("Received Decrypted Message: ");
    Serial.println(lastReceivedMessage);
    updateDisplay();
  }

  if (currentState == COMPOSING) {
    if (rotaryEncoder.encoderChanged()) {
      updateDisplay();
    }
    processButton();
  }

  if (digitalRead(USER_BUTTON_PIN) == LOW) {
    delay(50);
    if (digitalRead(USER_BUTTON_PIN) == LOW) {
      if (currentState == COMPOSING) {
        if (lastReceivedMessage != "No messages yet.") {
          currentState = READING;
          hasUnreadMessage = false;
          updateDisplay();
        }
      } else {
        currentState = COMPOSING;
        updateDisplay();
      }
      while (digitalRead(USER_BUTTON_PIN) == LOW);
    }
  }

  delay(10);
}

 // --- GESTIONNAIRES D'ÉVÉNEMENTS LORA ET OUTILS ---
void OnTxDone(void) {
  Serial.println("TX done.");
  Radio.Sleep();
  lora_idle = true;
}
void OnTxTimeout(void) {
  Serial.println("TX Timeout.");
  Radio.Sleep();
  lora_idle = true;
}
void OnRxDone(uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr) {
    Radio.Sleep();
    memset(rxpacket, 0, sizeof(rxpacket));
    memcpy(rxpacket, payload, size > BUFFER_SIZE ? BUFFER_SIZE : size);
    decryptAES((uint8_t*)rxpacket, userKey);
    newPacketAvailable = true;
    lora_idle = true;
}

void sendData() {
  if (messageToCompose.length() > 0) {
    lora_idle = false;

    Radio.SetTxConfig(MODEM_LORA, TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,
                   LORA_SPREADING_FACTOR, LORA_CODINGRATE,
                   LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,
                   true, 0, 0, LORA_IQ_INVERSION_ON, 3000);

    uint8_t data[BUFFER_SIZE];
    memset(data, 0, BUFFER_SIZE);
    strncpy((char*)data, messageToCompose.c_str(), BUFFER_SIZE - 1);

    encryptAES(data, userKey);

    Serial.print("Sending message: ");
    Serial.println(messageToCompose);

    Radio.Send(data, 16);

    messageToCompose = "";
  }
}

 // --- LOGIQUE D'AFFICHAGE ET DE BOUTON ---
void updateDisplay() {
  display.clear();
  display.setTextAlignment(TEXT_ALIGN_LEFT);

  if (currentState == COMPOSING) {
    selectedChar = charset[rotaryEncoder.readEncoder()];
    display.setFont(ArialMT_Plain_10);

 // --- CECI EST LA SOLUTION pour la notification ---
    String msgLabel;
    if (hasUnreadMessage) {
        msgLabel = ">> NEW MSG <<"; // Rendez la notification très évidente
    } else {
        msgLabel = "Msg:";
    }
    display.drawStringMaxWidth(0, 0, 128, msgLabel + " " + messageToCompose);

    display.setFont(ArialMT_Plain_16);
    int16_t labelWidth = display.getStringWidth("Select: ");
    display.drawString(0, 35, "Select: ");
    display.setFont(ArialMT_Plain_24);
    display.drawString(labelWidth, 32, String(selectedChar));
  } else { // currentState == LECTURE
    display.setFont(ArialMT_Plain_16);
    display.drawString(0, 0, "Received:");
    display.setFont(ArialMT_Plain_10);
    display.drawStringMaxWidth(0, 18, 128, lastReceivedMessage);
  }

  display.display();
}

void processButton() {
    if (doubleClickWaiting && (millis() - buttonUpTime > doubleClickTimeout)) {
        doubleClickWaiting = false;
        on_button_short_click();
    }
    bool isButtonDown = rotaryEncoder.isEncoderButtonDown();
    if (isButtonDown && !buttonWasDown) {
        buttonDownTime = millis();
        buttonWasDown = true;
    }
    else if (!isButtonDown && buttonWasDown) {
        unsigned long pressDuration = millis() - buttonDownTime;
        if (pressDuration >= longPressAfterMiliseconds) {
            on_button_long_click();
            doubleClickWaiting = false;
        }
        else if (pressDuration >= shortPressAfterMiliseconds) {
            if (doubleClickWaiting) {
                on_button_double_click();
                doubleClickWaiting = false;
            } else {
                doubleClickWaiting = true;
                buttonUpTime = millis();
            }
        }
        buttonWasDown = false;
    }
}

 // --- SERVICES ---
void VextON(void) {
  pinMode(Vext,OUTPUT);
  digitalWrite(Vext, LOW);
}
void processKey(const char *userKey, uint8_t *processedKey, size_t keySize) {
    memset(processedKey, 0, keySize);
    size_t len = strlen(userKey);
    if (len > keySize) len = keySize;
    memcpy(processedKey, userKey, len);
}
void encryptAES(uint8_t *data, const char *key) {
    uint8_t processedKey[16];
    processKey(key, processedKey, 16);
    mbedtls_aes_init(&aes);
    mbedtls_aes_setkey_enc(&aes, processedKey, 128);
    mbedtls_aes_crypt_ecb(&aes, MBEDTLS_AES_ENCRYPT, data, data);
    mbedtls_aes_free(&aes);
}
void decryptAES(uint8_t *data, const char *key) {
    uint8_t processedKey[16];
    processKey(key, processedKey, 16);
    mbedtls_aes_init(&aes);
    mbedtls_aes_setkey_dec(&aes, processedKey, 128);
    mbedtls_aes_crypt_ecb(&aes, MBEDTLS_AES_DECRYPT, data, data);
    mbedtls_aes_free(&aes);
}
786-Secure, Long-Range LoRa Chat Device Heltec WiFi LoRa 32 with buzzer
Langue: C++
/*
 * Projet ESP32 : Création d’un dispositif de chat LoRa sécurisé et longue portée Heltec WiFi LoRa 32
 * 
 * Fichier : Heltec_ESP32_LoRa_V3_chat_TX_RX_buzzer.ino
 * Rédigé le 29 juin 2025 par Ahmad Shamshiri www.Roboajx.com
 * Regardez le tutoriel vidéo à l’adresse : https://youtu.be/IsOSvrF60J4
 * Page de ressources pour cette vidéo : https://robojax.com/RJT642
 * 
 * =====================================================================
 * DESCRIPTION DU CODE ARDUINO : Émetteur-récepteur clavier LoRa SÉCURISÉ (système de chat)
 * =====================================================================
 * 
 * COMPOSANTS MATÉRIELS :
 * -------------------
 * - Contrôleur principal : Heltec WiFi LoRa 32 V3
 * - Boîtier : Boîtier Meshnology N33 Avec batterie 3000 mAh
 * - Entrée : Encodeur rotatif avec bouton-poussoir
 * - Signal sonore : Buzzer actif (connecté à la broche 40)
 * - Retour : Écran OLED intégré
 * 
 * FONCTIONNALITÉS :
 * -------------------
 * NOUVELLES COMMANDES :
 * - Tourner le bouton : Sélectionner un caractère.
 * - Appui court (clic) : Ajouter le caractère sélectionné.
 * - Appui long (maintenir) : Insérer un espace (comme une barre d'espace).
 * - Double clic : Retour arrière.
 * 
 * [2] TRANSMISSION SANS FIL SÉCURISÉE :
 * - Tous les messages sont chiffrés avant la transmission LoRa
 * - Commande de position initiale transmise sous forme de paquet sécurisé spécial
 * - Utilise la bande LoRa 433 MHz/915 MHz pour une communication fiable
 * 
 * [3] GESTION DE L'ÉNERGIE :
 * - Optimisé pour un fonctionnement sur batterie (3 000 mAh)
 * - Modes basse consommation entre les transmissions
 * 
 * POUR LES INSTRUCTIONS DE CONFIGURATION COMPLÈTES :
 * Veuillez regarder le tutoriel vidéo à l'adresse : https://youtu.be/IsOSvrF60J4
 * Page des ressources de cette vidéo : https://robojax.com/RJT642
 * ==================================================================
 * 
 * AVERTISSEMENT :
 * Ce code est fourni « EN L'ÉTAT » sans aucune garantie. L'auteur ne saurait être tenu responsable des dommages résultant de son utilisation.
 * 
 * LICENCE :
 * Cette œuvre est sous licence GNU General Public License v3.0.
 * Les autorisations au-delà de cette licence peuvent être obtenues sur Robojax.com.
 * 
 * CONDITIONS DE PARTAGE :
 * Vous êtes libre de partager, copier et modifier ce code à des fins non commerciales.
 * À CONDITION :
 * 1. De conserver l'intégralité de ce bloc de commentaires avec le code original.
 * 2. D'inclure le lien Robojax.com original.
 * 3. De conserver le lien du tutoriel YouTube (le cas échéant).
 * 4. D'indiquer clairement toute modification apportée.
 * 
 * /
 * 
 * // Bibliothèques Core Heltec et d'affichage.
 */
#include <Wire.h>
#include "HT_SSD1306Wire.h"
#include "WiFi.h"

 // Bibliothèques LoRa et de sécurité
#include "LoRaWan_APP.h"
#include "mbedtls/aes.h"
#include <cstring>

 // La bibliothèque d'encodeurs rotatifs approuvée par les utilisateurs
#include "AiEsp32RotaryEncoder.h"

 // --- DÉFINITIONS ET CONFIGURATION DES BROCHES ---
static SSD1306Wire  display(0x3c, 500000, SDA_OLED, SCL_OLED, GEOMETRY_128_64, RST_OLED);

#define ROTARY_ENCODER_A_PIN 5 // broche A de l'encodeur rotatif
#define ROTARY_ENCODER_B_PIN 6 // broche B de l'encodeur rotatif
#define ROTARY_ENCODER_BUTTON_PIN 4 // broche de commutation de l'encodeur rotatif

#define BUZZER_PIN 40 // la broche du buzzer ou le relais à déclencher
const bool DEBUG = false;

#define RF_FREQUENCY 915432000 // fréquence de fonctionnement de LoRa
#define TX_OUTPUT_POWER 2 // la puissance de sortie doit être comprise entre 2 et 21 dBm.
const char *userKey = "wahJ8uy$gt~_3r"; // clé de sécurité pour la communication privée

#define ROTARY_ENCODER_VCC_PIN -1
#define ROTARY_ENCODER_STEPS 4

 // --- PARAMÈTRES LORA ---
#define LORA_BANDWIDTH 0
#define LORA_SPREADING_FACTOR 7
#define LORA_CODINGRATE 1
#define LORA_PREAMBLE_LENGTH 8
#define LORA_SYMBOL_TIMEOUT 0
#define LORA_FIX_LENGTH_PAYLOAD_ON false
#define LORA_IQ_INVERSION_ON false
#define BUFFER_SIZE 256

#define LOOP_DELAY 10
 // Variables d'état du buzzer
unsigned long buzzerStartTime = 0;
bool isBuzzerActive = false;
int beepPhase = 0; // 0 = inactif, 1 = premier bip, 2 = pause, 3 = deuxième bip

#define USER_BUTTON_PIN 0
 // --- VARIABLES GLOBALES ET ÉTAT ---
enum AppState { COMPOSING, READING };
AppState currentState = COMPOSING;
String messageToCompose = "";
String lastReceivedMessage = "No messages yet.";
bool hasUnreadMessage = false;
volatile bool newPacketAvailable = false;
char rxpacket[BUFFER_SIZE];
AiEsp32RotaryEncoder rotaryEncoder = AiEsp32RotaryEncoder(ROTARY_ENCODER_A_PIN, ROTARY_ENCODER_B_PIN, ROTARY_ENCODER_BUTTON_PIN, ROTARY_ENCODER_VCC_PIN, ROTARY_ENCODER_STEPS);
const char* charset = " ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.,!?>";
char selectedChar;
static RadioEvents_t RadioEvents;
bool lora_idle = true;

mbedtls_aes_context aes;
unsigned long shortPressAfterMiliseconds = 50;
unsigned long longPressAfterMiliseconds = 1000;
unsigned long doubleClickTimeout = 400;
static unsigned long buttonDownTime = 0;
static unsigned long buttonUpTime = 0;
static bool buttonWasDown = false;
static bool doubleClickWaiting = false;

 // --- PROTOTYPES DE FONCTION ---
void OnTxDone(void);
void OnTxTimeout(void);
void OnRxDone(uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr);
void encryptAES(uint8_t *data, const char *key);
void decryptAES(uint8_t *data, const char *key);
void processKey(const char *userKey, uint8_t *processedKey, size_t keySize);
void updateDisplay();
void sendData();
void VextON(void);
void processButton();
void buzzer();
void updateBuzzer();


 // --- INTERROMPRE LES ROUTINES DE SERVICE ---
void IRAM_ATTR readEncoderISR() {
  rotaryEncoder.readEncoder_ISR();
}

 // --- ACTIONS DU GESTIONNAIRE DE BOUTONS ---
void on_button_short_click() {
  if (currentState != COMPOSING) return;
  if (selectedChar == '>') {
      sendData();
  } else {
    messageToCompose += selectedChar;
  }
  updateDisplay();
}
void on_button_long_click() {
  if (currentState != COMPOSING) return;
  messageToCompose += " ";
  updateDisplay();
}
void on_button_double_click() {
  if (currentState != COMPOSING) return;
  if (messageToCompose.length() > 0) {
    messageToCompose.remove(messageToCompose.length() - 1);
  }
  updateDisplay();
}

 // --- INSTALLATION ---
void setup() {
  Serial.begin(115200);
  Serial.println("LoRa Keyboard Transceiver - By Robojax");

  VextON();
  delay(100);
  Mcu.begin(HELTEC_BOARD,SLOW_CLK_TPYE);
  WiFi.mode(WIFI_OFF);
  btStop();

  display.init();
  display.setFont(ArialMT_Plain_10);

  rotaryEncoder.begin();
  rotaryEncoder.setup(readEncoderISR);
  rotaryEncoder.setBoundaries(0, strlen(charset) - 1, true);
  rotaryEncoder.disableAcceleration();

  pinMode(USER_BUTTON_PIN, INPUT_PULLUP);
  pinMode(BUZZER_PIN, OUTPUT);

  RadioEvents.TxDone = OnTxDone;
  RadioEvents.TxTimeout = OnTxTimeout;
  RadioEvents.RxDone = OnRxDone;
  Radio.Init(&RadioEvents);
  Radio.SetChannel(RF_FREQUENCY);

  Radio.SetRxConfig(MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,
                   LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,
                   LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON,
                   0, true, 0, 0, LORA_IQ_INVERSION_ON, true);

  updateDisplay();
}

 // --- BOUCLE PRINCIPALE ---
void loop() {
  if(lora_idle) {
    lora_idle = false;
    if(DEBUG)
    {
    Serial.println("Entering RX mode...");
    }

    Radio.Rx(0);
  }
  Radio.IrqProcess();

  if (newPacketAvailable) {
    newPacketAvailable = false;
    hasUnreadMessage = true;
    lastReceivedMessage = String(rxpacket);
    if(DEBUG)
    {
    Serial.print("Received Decrypted Message: ");
    Serial.println(lastReceivedMessage);
    }
    updateDisplay();
    buzzer();
  }

  if (currentState == COMPOSING) {
    if (rotaryEncoder.encoderChanged()) {
      updateDisplay();
    }
    processButton();
  }

  if (digitalRead(USER_BUTTON_PIN) == LOW) {
    delay(50);
    if (digitalRead(USER_BUTTON_PIN) == LOW) {
      if (currentState == COMPOSING) {
        if (lastReceivedMessage != "No messages yet.") {
          currentState = READING;
          hasUnreadMessage = false;
          updateDisplay();
        }
      } else {
        currentState = COMPOSING;
        updateDisplay();
      }
      while (digitalRead(USER_BUTTON_PIN) == LOW);
    }
  }

  updateBuzzer(); // Mettre à jour l'état du buzzer (non bloquant)
  delay(LOOP_DELAY); // Votre délai de boucle de 10 ms
}

 // --- GESTIONNAIRES ET AIDE À L'ÉVÉNEMENT LORA ---
void OnTxDone(void) {
    if(DEBUG)
    {
      Serial.println("TX done.");
    }
  Radio.Sleep();
  lora_idle = true;
}
void OnTxTimeout(void) {
    if(DEBUG)
    {
      Serial.println("TX Timeout.");
    }
  Radio.Sleep();
  lora_idle = true;
}
void OnRxDone(uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr) {
    Radio.Sleep();
    memset(rxpacket, 0, sizeof(rxpacket));
    memcpy(rxpacket, payload, size > BUFFER_SIZE ? BUFFER_SIZE : size);
    decryptAES((uint8_t*)rxpacket, userKey);
    newPacketAvailable = true;
    lora_idle = true;
}

void sendData() {
  if (messageToCompose.length() > 0) {
    lora_idle = false;

    Radio.SetTxConfig(MODEM_LORA, TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,
                   LORA_SPREADING_FACTOR, LORA_CODINGRATE,
                   LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,
                   true, 0, 0, LORA_IQ_INVERSION_ON, 3000);

    uint8_t data[BUFFER_SIZE];
    memset(data, 0, BUFFER_SIZE);
    strncpy((char*)data, messageToCompose.c_str(), BUFFER_SIZE - 1);

    encryptAES(data, userKey);
    if(DEBUG)
    {
    Serial.print("Sending message: ");
    Serial.println(messageToCompose);
    }

    Radio.Send(data, 16);

    messageToCompose = "";
  }
}

 // --- LOGIQUE D'AFFICHAGE ET DE BOUTONS ---
void updateDisplay() {
  display.clear();
  display.setTextAlignment(TEXT_ALIGN_LEFT);

  if (currentState == COMPOSING) {
    selectedChar = charset[rotaryEncoder.readEncoder()];
    display.setFont(ArialMT_Plain_10);

 // --- CECI EST LA CORRECTION pour la notification ---
    String msgLabel;
    if (hasUnreadMessage) {
        msgLabel = ">> NEW MSG <<"; // Rendre la notification très évidente
    } else {
        msgLabel = "Msg:";
    }
    display.drawStringMaxWidth(0, 0, 128, msgLabel + " " + messageToCompose);

    display.setFont(ArialMT_Plain_16);
    int16_t labelWidth = display.getStringWidth("Select: ");
    display.drawString(0, 35, "Select: ");
    display.setFont(ArialMT_Plain_24);
    display.drawString(labelWidth, 32, String(selectedChar));
  } else { // currentState == LECTURE
    display.setFont(ArialMT_Plain_16);
    display.drawString(0, 0, "Received:");
    display.setFont(ArialMT_Plain_10);
    display.drawStringMaxWidth(0, 18, 128, lastReceivedMessage);
  }

  display.display();
}

void processButton() {
    if (doubleClickWaiting && (millis() - buttonUpTime > doubleClickTimeout)) {
        doubleClickWaiting = false;
        on_button_short_click();
    }
    bool isButtonDown = rotaryEncoder.isEncoderButtonDown();
    if (isButtonDown && !buttonWasDown) {
        buttonDownTime = millis();
        buttonWasDown = true;
    }
    else if (!isButtonDown && buttonWasDown) {
        unsigned long pressDuration = millis() - buttonDownTime;
        if (pressDuration >= longPressAfterMiliseconds) {
            on_button_long_click();
            doubleClickWaiting = false;
        }
        else if (pressDuration >= shortPressAfterMiliseconds) {
            if (doubleClickWaiting) {
                on_button_double_click();
                doubleClickWaiting = false;
            } else {
                doubleClickWaiting = true;
                buttonUpTime = millis();
            }
        }
        buttonWasDown = false;
    }
}


void buzzer()
{
  if (!isBuzzerActive) {
    isBuzzerActive = true;
    buzzerStartTime = millis(); // Démarrer la séquence du buzzer
    beepPhase = 1; // Premier bip
    digitalWrite(BUZZER_PIN, HIGH);
  }
}
void updateBuzzer() {
  if (!isBuzzerActive) return;

  unsigned long currentTime = millis();
  unsigned long elapsed = currentTime - buzzerStartTime;

  switch (beepPhase) {
    case 1: // Premier bip (300 ms allumé)
      if (elapsed >= 300) {
        digitalWrite(BUZZER_PIN, LOW);
        buzzerStartTime = currentTime;
        beepPhase = 2; // Déplacer pour mettre en pause
      }
      break;

    case 2: // Pause (200 ms OFF)
      if (elapsed >= 200) {
        digitalWrite(BUZZER_PIN, HIGH);
        buzzerStartTime = currentTime;
        beepPhase = 3; // Passer au deuxième bip
      }
      break;

    case 3: // Deuxième bip (300 ms allumé)
      if (elapsed >= 300) {
        digitalWrite(BUZZER_PIN, LOW);
        isBuzzerActive = false; // Réinitialiser
        beepPhase = 0;
      }
      break;
  }
}
 // --- SERVICES PUBLICS ---
void VextON(void) {
  pinMode(Vext,OUTPUT);
  digitalWrite(Vext, LOW);
}
void processKey(const char *userKey, uint8_t *processedKey, size_t keySize) {
    memset(processedKey, 0, keySize);
    size_t len = strlen(userKey);
    if (len > keySize) len = keySize;
    memcpy(processedKey, userKey, len);
}
void encryptAES(uint8_t *data, const char *key) {
    uint8_t processedKey[16];
    processKey(key, processedKey, 16);
    mbedtls_aes_init(&aes);
    mbedtls_aes_setkey_enc(&aes, processedKey, 128);
    mbedtls_aes_crypt_ecb(&aes, MBEDTLS_AES_ENCRYPT, data, data);
    mbedtls_aes_free(&aes);
}
void decryptAES(uint8_t *data, const char *key) {
    uint8_t processedKey[16];
    processKey(key, processedKey, 16);
    mbedtls_aes_init(&aes);
    mbedtls_aes_setkey_dec(&aes, processedKey, 128);
    mbedtls_aes_crypt_ecb(&aes, MBEDTLS_AES_DECRYPT, data, data);
    mbedtls_aes_free(&aes);
}

Common Course Links

Common Course Files

Ressources et références

Fichiers📁

Autres fichiers

← Leçon précédente

Produits Amazon associés

Annonces eBay associées

Produits AliExpress associés

Balises

HeltecMeshnologyMeshnology N33WiFi LoRa 32
Code de recherche

Derniers tutoriels

Vignette YouTube
Vignette YouTube
Vignette YouTube
Vignette YouTube
Vignette YouTube
Vignette YouTube
Vignette YouTube
Vignette YouTube
Vignette YouTube
Vignette YouTube
Voir plus