Usando o Heltec WiFi LoRa 32 V3 para transmitir temperatura usando DHT22 a 1,4 km.

Este tutorial faz parte de: Tutoriais WiFi LoRa 32

Todos os vídeos relacionados ao Heltec WiFi LoRa 32 estão neste grupo. Os links para outros vídeos estão abaixo deste artigo.

Esta lição faz parte de: Introdução ao WiFi LoRa

Saltar para:

Todas as Lições

Assista no YouTube

Usando o Heltec WiFi LoRa 32 V3 para transmitir temperatura usando DHT22 a 1,4 km.

Neste tutorial, exploraremos como utilizar o módulo Heltec WiFi LoRa 32 V3 para transmitir dados de temperatura de um sensor DHT22 a longas distâncias, alcançando distâncias de até 1,4 quilômetros. Essa capacidade é possível graças ao uso da tecnologia LoRa, que permite comunicação de longo alcance com baixo consumo de energia. Ao final deste guia, você terá um sistema funcional que pode enviar leituras de temperatura sem fio.

Wifi LoRa 32 V3 dentro do Meshnology N30 RX e TX

Começaremos com uma visão geral dos componentes de hardware envolvidos neste projeto, incluindo o módulo Heltec WiFi LoRa 32 V3 e o sensor DHT22. Em seguida, passaremos às instruções de fiação, onde você aprenderá como conectar esses componentes. Por fim, percorreremos o código necessário para tornar este sistema operacional. Para orientação visual, consulte o vídeo em vários horários (no vídeo em 00:00).

Hardware Explicado

Os principais componentes deste projeto são o módulo Heltec WiFi LoRa 32 V3 e o sensor de temperatura e umidade DHT22. O módulo Heltec possui um microcontrolador ESP32, que oferece capacidades de Wi-Fi e Bluetooth, além da comunicação LoRa. Isso permite opções flexíveis de transmissão de dados.

Wifi LoRa 32 V3 dentro do Meshnology N30 como transmissor de Temperatura

O sensor DHT22 é um sensor digital que fornece leituras precisas de temperatura e umidade. Ele se comunica com o ESP32 por meio de um único pino de saída digital, facilitando a conexão e o uso em seus projetos. Juntos, esses componentes formam um sistema robusto para monitoramento de temperatura sem fio.

Detalhes da Ficha Técnica

Fabricante	Heltec Automation
Número da peça	WiFi LoRa 32 V3
Tensão lógica/IO	3,3 V
Tensão de alimentação	3,7-4,2 V
Corrente de saída (por canal)	~1 A
Corrente de pico (por canal)	~2 A
Orientação da frequência de PWM	1 kHz (típ.)
Limiares de lógica de entrada	0,7 V (alto), 0,3 V (baixo)
Queda de tensão / R_DS(on)/ saturação	0,3 V (máx)
Limites térmicos	85 °C (máx)
Pacote	Módulo de PCB
Notas / variantes	Várias opções de frequência disponíveis (por exemplo, 433 MHz, 868 MHz, 915 MHz)

Certifique-se de alimentar o DHT22 com 3,3V, não com 5V.
Use níveis lógicos apropriados para comunicação entre o ESP32 e o DHT22.
Considere o dissipador de calor se operar com altas correntes por períodos prolongados.
Verifique a conexão da antena para LoRa para maximizar o alcance.
Esteja atento às regulamentações de frequência LoRa na sua região.

Instruções de Fiação

Para conectar o Heltec WiFi LoRa 32 V3 com o sensor DHT22, comece ligando o pino VCC do sensor ao pino de 3,3V no módulo Heltec. Em seguida, conecte o pino GND do DHT22 a um dos pinos GND do Heltec. O pino de dados do DHT22 deve ser conectado ao pino GPIO 3 no Heltec.

Certifique-se de usar um resistor pull-up (cerca de 10kΩ) entre o pino de dados e o VCC para leituras estáveis. Além disso, verifique se a antena LoRa está conectada de forma segura para aumentar o alcance de transmissão. Se você estiver usando energia externa, garanta que o módulo Heltec esteja alimentado corretamente para evitar quaisquer problemas operacionais.

Instalando placas Heltec ESP32

Adicione este caminho nas preferências do seu Arduino IDE, conforme mostrado no vídeo:https://resource.heltec.cn/download/package_heltec_esp32_index.json

Exemplos de Código e Tutorial

Os seguintes trechos de código ilustram como configurar o módulo Heltec para ler dados de temperatura do sensor DHT22 e transmiti-los via LoRa. O código inicializa o display e configura o sensor DHT.

#include 
#define DHTPIN 3         // GPIO pin for DHT22
#define DHTTYPE DHT22    // Define DHT type
DHT dht(DHTPIN, DHTTYPE);
void setup() {
  Serial.begin(115200);
  dht.begin(); // Initialize DHT sensor
}

Neste trecho, definimos o pino ao qual o sensor DHT22 está conectado e o inicializamos nosetup()função. OSerial.begin(115200)a linha é para saída de depuração.

void loop() {
  float tempC = dht.readTemperature(); // Read temperature in Celsius
  float tempF = dht.convertCtoF(tempC); // Convert to Fahrenheit
  sendData(tempC, tempF); // Function to send temperature data
}

Este excerto mostra como ler dados de temperatura naloop()função. OsendData()a função é chamada para transmitir as leituras de temperatura via LoRa.

void sendData(float tempC, float tempF) {
  String data = "Temperature: " + String(tempC) + "°C"; // Create data string
  Radio.Send(data.c_str(), data.length()); // Send data
}

Aqui, criamos a string de dados contendo a temperatura e a enviamos usando aRadio.Send()método. Isso transmitirá os dados sem fio para o módulo receptor.

Por favor, consulte o código completo carregado abaixo do artigo para uma implementação detalhada.

Demonstração / O Que Esperar

Uma vez que tudo esteja configurado e o código esteja carregado no módulo Heltec, você deve ver as leituras de temperatura exibidas na tela OLED. O sistema transmitirá os dados de temperatura, que podem ser recebidos por outro módulo Heltec configurado para ler os dados. Você pode testar o alcance movendo o receptor para longe do transmissor, confirmando a distância máxima alcançada (no vídeo em 1:30).

Tenha cuidado com armadilhas comuns, como fiação incorreta, fornecimento de energia insuficiente ou uso da frequência LoRa errada. Certifique-se de que o DHT22 esteja funcionando corretamente e que a antena esteja conectada para maximizar o alcance.

Marcação de Tempo do Vídeo

00:00 Início
3:51 Especificações
8:32 Página de documentação
9:52 Pacote e bateria
12:58 Ligando-o pela primeira vez
16:37 Instalando a Biblioteca
18:19 Código básico do transmissor
19:43 Código Básico do Receptor
20:39 Demonstração de envio e recebimento de texto
23:02 código de demonstração OLED
24:06 Texto Básico sobre código para display OLED
26:26 Texto básico sobre a demonstração de OLED
26:58 Lendo temperatura com DHT22
28:49 Temperatura e Exibição do Transmissor LoRa
30:07 Temperatura do Receptor LoRa e Exibição
32:13 Acionando LED quando a temperatura aumenta
22:26 Teste de Alcance de Transmissão LoRa
35:01 dBm e Milli Watt

Imagens

Heltec_WiFi_loRa_32V3_DHT22_wiring

Wifi LoRa 32 V3 inside Meshnology N30 as transmitter of Temperature

meshnology-N30-LoRa-v3-red-black

Wifi LoRa 32 V3 inside Meshnology N30 RX and TX

Este tutorial é parte de: Tutoriais WiFi LoRa 32

Por favor, visualize esta página em inglês se o código não estiver visível. Pedimos desculpas pelo transtorno.

563-Printing Simple Text on the screen of WiFi LoRa 32 V3

Idioma: C++

/*
This is a simple code to display text on the OLED display
WiFi LoRa 32 V3 ESP32 module
Written by Ahmad Shamshiri 02 April 2025
Watch full video explanation https://youtu.be/WkyQMXkQhE8
Resources page https://robojax.com/tutorial_view.php?id=387
*/
#include <Wire.h>               
#include "HT_SSD1306Wire.h"


static SSD1306Wire  display(0x3c, 500000, SDA_OLED, SCL_OLED, GEOMETRY_128_64, RST_OLED); // addr , freq , i2c group , resolution , rst


void setup() {
  Serial.begin(115200);
  Serial.println();
  Serial.println();
  VextON();
  delay(100);

  // Initialising the UI will init the display too.
  display.init();

  display.setFont(ArialMT_Plain_10);

}


void displayTemperature(double temperature, int unit) {
    display.clear();  // Clear display before new content
    
    // Line 1: "Temperature:" in 16pt font
    display.setTextAlignment(TEXT_ALIGN_LEFT);
    display.setFont(ArialMT_Plain_16);
    display.drawString(0, 0, "Temperature:");

    // Line 2: Temperature value in 24pt font
    display.setFont(ArialMT_Plain_24);
    
    // Format temperature with correct unit symbol
    String tempString = String(temperature, 1); // 1 decimal place
    switch(unit) {
        case 1:  tempString += "ï¿½C"; break;  // Celsius
        case 2:  tempString += "ï¿½F"; break;  // Fahrenheit
        default: tempString += "ï¿½U"; break;  // Unknown unit
    }
    
    display.drawString(0, 20, tempString);  // Display at Y=20 (below label)
    display.display();  // Update OLED
}



void VextON(void)
{
  pinMode(Vext,OUTPUT);
  digitalWrite(Vext, LOW);
}

void VextOFF(void) //Vext default OFF
{
  pinMode(Vext,OUTPUT);
  digitalWrite(Vext, HIGH);
}



void loop() {
  // clear the display
  display.clear();
  displayTemperature(23.5, 1); // Displays "23.5ï¿½C" /1
  delay(2000);

}

773-Transmitter Code for Heltec WiFi LoRa 32 V3 to send temperature using DHT11, DHT22

Idioma: C++

/*
written on March 27, 2025
written by Ahmad Shamshiri for www.Robojax.com
Transmits Temperature and Humidity over LoRa RF using ESP32 LoRA 32 V3 module.
and displays the information on the screen.
Watch full video explanation https://youtu.be/WkyQMXkQhE8
Resources page: https://robojax.com/tutorial_view.php?id=387
*/

#include <Wire.h>               
#include "HT_SSD1306Wire.h"
static SSD1306Wire  display(0x3c, 500000, SDA_OLED, SCL_OLED, GEOMETRY_128_64, RST_OLED); // addr , freq , i2c group , resolution , rst

#include <DHT.h>
#define DHTPIN 3         // GPIO21
#define DHTTYPE DHT22     // DHT22 (AM2302)

DHT dht(DHTPIN, DHTTYPE);

float tempC, tempF;
int humidity ;

  //1=C
  //2=F
  //3=C, Humidity //only for display not for transmission
  //4=F, Humidity //only for display not for transmission
  //5=Humidity only
int dataType = 2;
String labelTemp = "Temperature";
String labelHumidity = "Humidity";
const int TX_POWER = 2;//dBm from 2 to 20. when powered via battery 2 to 14dBm is the best option

#include "mbedtls/aes.h"
#include <cstring>  // For memset, memcpy
mbedtls_aes_context aes;
const char *userKey = "hyhT676#h~_876s"; //Security key. 


#include "LoRaWan_APP.h"
#include "Arduino.h"


#define RF_FREQUENCY                                915000000 // Hz

#define TX_OUTPUT_POWER                             TX_POWER        // dBm from 2 to 20. when powered via battery 2 to 14dBm

#define LORA_BANDWIDTH                              0         // [0: 125 kHz,
                                                              //  1: 250 kHz,
                                                              //  2: 500 kHz,
                                                              //  3: Reserved]
#define LORA_SPREADING_FACTOR                       7         // [SF7..SF12]
#define LORA_CODINGRATE                             1         // [1: 4/5,
                                                              //  2: 4/6,
                                                              //  3: 4/7,
                                                              //  4: 4/8]
#define LORA_PREAMBLE_LENGTH                        8         // Same for Tx and Rx
#define LORA_SYMBOL_TIMEOUT                         0         // Symbols
#define LORA_FIX_LENGTH_PAYLOAD_ON                  false
#define LORA_IQ_INVERSION_ON                        false


#define RX_TIMEOUT_VALUE                            1000
#define BUFFER_SIZE                                 30 // Define the payload size here

char txpacket[BUFFER_SIZE];
char rxpacket[BUFFER_SIZE];

double txNumber;

bool lora_idle=true;

static RadioEvents_t RadioEvents;
unsigned long lastTxTime = 0;
void OnTxDone( void );
void OnTxTimeout( void );
void decryptAES(uint8_t *data, const char *key);
void encryptAES(uint8_t *data, const char *key);
void processKey(const char *userKey, uint8_t *processedKey, size_t keySize);

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

  VextON();
  delay(100);

  // Initialising the UI will init the display too.
  display.init();

  display.setFont(ArialMT_Plain_10);
   dht.begin();

  //LoRa stuff
  Mcu.begin(HELTEC_BOARD,SLOW_CLK_TPYE);
	
    txNumber=0;

    RadioEvents.TxDone = OnTxDone;
    RadioEvents.TxTimeout = OnTxTimeout;
    
    Radio.Init( &RadioEvents );
    Radio.SetChannel( RF_FREQUENCY );
    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 );   

}


void displayTemperature(int unit) {
    display.clear();  // Clear display before new content
    
    // Line 1: "Temperature:" in 16pt font
    display.setTextAlignment(TEXT_ALIGN_LEFT);


    // Line 2: Temperature value in 24pt font
    display.setFont(ArialMT_Plain_24);
    
    // Format temperature with correct unit symbol
    String tempStringC = String(tempC, 1) + "Â°C"; // 1 decimal place
    String tempStringF = String(tempF, 1)+ "Â°F"; // 1 decimal place
    String tempStringHumidity = String(humidity)+ "% RH";   
    String tempString; 
    switch(unit) {
        case 1:  
          tempString =tempStringC; 
          display.setFont(ArialMT_Plain_16);
          display.drawString(0, 0, "Temperature:");        
          display.setFont(ArialMT_Plain_24);
          display.drawString(0, 15, tempString);  
          break;  // Celsius
        case 2:  tempString =tempStringF; 
          display.setFont(ArialMT_Plain_16);
          display.drawString(0, 0, "Temperature:");              
          display.setFont(ArialMT_Plain_24);
          display.drawString(0, 15, tempString);  
          break;  // Fahrenheit
        case 3:  tempString =tempStringC; 
          display.setFont(ArialMT_Plain_16);
          display.drawString(0, 0, "Temperature:");              
          display.setFont(ArialMT_Plain_24);        
          display.drawString(0, 15, tempString);  
          display.setFont(ArialMT_Plain_16);
          display.drawString(0, 40, "Humidity:");
          display.drawString(70, 40, tempStringHumidity);       
          break;  // Celsius    
        case 4:  tempString =tempStringF; 
          display.setFont(ArialMT_Plain_16);
          display.drawString(0, 0, "Temperature:");              
          display.setFont(ArialMT_Plain_24);        
          display.drawString(0, 15, tempString);  
          display.setFont(ArialMT_Plain_16);
          display.drawString(0, 40, "Humidity:");
          display.drawString(70, 40, tempStringHumidity );       
          break;  // Celsius       
        case 5: 
          display.setFont(ArialMT_Plain_16);
          display.drawString(0, 0, "Humidity:");
          display.setFont(ArialMT_Plain_24); 
          display.drawString(0, 20, tempStringHumidity);         
          break;  // Celsius                     
        default: tempString =tempStringC + "Â°C"; break;;  // default
    }
    

    display.display();  // Update OLED
}

void readSensor()
{
  tempC = dht.readTemperature();
  humidity = dht.readHumidity(); 
  tempF = dht.convertCtoF(tempC);
}


void VextON(void)
{
  pinMode(Vext,OUTPUT);
  digitalWrite(Vext, LOW);
}

void VextOFF(void) //Vext default OFF
{
  pinMode(Vext,OUTPUT);
  digitalWrite(Vext, HIGH);
}

void sendData()
{
  

    String tempStringC = String(tempC, 1) + " Â°C"; // 1 decimal place
    String tempStringF = String(tempF, 1)+ " Â°F"; // 1 decimal place
    String tempStringHumidity = String(humidity)+ " % RH";   
    String txData; 
    //1=C
    //2=F
    //3=C, Humidity
    //4=F, Humidity
    //5=Humidity only
        switch(dataType) {
          case 1: 
           txData = labelTemp + " " + tempStringC;
            break; 
          case 2: 
           txData =  labelTemp + " " + tempStringF;
            break;
          case 3: 
           txData = labelHumidity + " " + tempStringHumidity;
            break;             
          default:
           txData = labelTemp + " " + tempStringC;
            break;

        }
  uint8_t data[32];       
  memset(data, 0, sizeof(data));  // Zero-padding
  strncpy((char*)data, txData.c_str(), sizeof(data) - 1); // Copy string safely

  encryptAES(data, userKey);  // Encrypt before sending  
  if(lora_idle == true)
    {
      delay(1000);
      Radio.Send(data,  sizeof(data));
      Serial.print("Sending: ");
      Serial.println((char *)data);
      lora_idle = false;
    }
    Radio.IrqProcess( );  
}



void loop() {
  readSensor();//read the data

  // clear the display
  display.clear();

  displayTemperature(dataType); // 
	sendData();
  delay(100);

}


void OnTxDone( void )
{
	Serial.println("TX done......");
	lora_idle = true;
}

void OnTxTimeout( void )
{
    Radio.Sleep( );
    Serial.println("TX Timeout......");
    lora_idle = true;
}


/**
 * Converts a user-provided plaintext key into a fixed-length 16-byte (128-bit)
 * or 32-byte (256-bit) key.
 */
void processKey(const char *userKey, uint8_t *processedKey, size_t keySize) {
    memset(processedKey, 0, keySize); // Fill with zeros
    size_t len = strlen(userKey);
    if (len > keySize) len = keySize; // Truncate if too long
    memcpy(processedKey, userKey, len); // Copy valid key part
}

/**
 * Encrypts a 16-byte (one block) message using AES-128.
 */
void encryptAES(uint8_t *data, const char *key) {
    uint8_t processedKey[16]; // 128-bit key
    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);
}

/**
 * Decrypts a 16-byte (one block) message using AES-128.
 */
void decryptAES(uint8_t *data, const char *key) {
    uint8_t processedKey[16]; // 128-bit key
    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);
}

867-Receiver Code for Heltec WiFi LoRa 32 to receive and display Temperature

Idioma: C++

/*
Written on April 01, 2025
written by Ahmad Shamshiri for www.Robojax.com
this sktech receives the secure temperature or humidity from WiFi LoRa 32 and decrypts it
and displays it on the OLED. There is action feature to triggerd if the temperature is below triggerdValue
Watch full video explaination https://youtu.be/WkyQMXkQhE8
Resources page: https://robojax.com/tutorial_view.php?id=387
*/
#include <Arduino.h>
// Alert configuration
const String triggerdText = "Too High"; // Correct String type
const float triggerdValue = 90.0f; // exclusive (this value is not included)
const int triggerdYpos = 45;
const bool triggerdType = true;//true is > (greter than triggerdValue) and false is < (less  than triggerdValue)
const int triggerdOutputPin = 7;//GPIO07 goes HIGH when triggered
const bool triggerdBlink4Me= true;//should blink or not

#include "mbedtls/aes.h"
#include <cstring>  // For memset, memcpy
mbedtls_aes_context aes;
const char *userKey = "hyhT676#h~_876s"; //Security key

#define MIN_RSSI -120  // Worst possible signal
#define MAX_RSSI -50   // Best possible signal


// For a connection via I2C using the Arduino Wire include:
#include <Wire.h>               
#include "HT_SSD1306Wire.h"

static SSD1306Wire  display(0x3c, 500000, SDA_OLED, SCL_OLED, GEOMETRY_128_64, RST_OLED); // addr , freq , i2c group , resolution , rst



#include "LoRaWan_APP.h"
#include "Arduino.h"


#define RF_FREQUENCY                                915000000 // Hz

#define TX_OUTPUT_POWER                             14        // dBm

#define LORA_BANDWIDTH                              0         // [0: 125 kHz,
                                                              //  1: 250 kHz,
                                                              //  2: 500 kHz,
                                                              //  3: Reserved]
#define LORA_SPREADING_FACTOR                       7         // [SF7..SF12]
#define LORA_CODINGRATE                             1         // [1: 4/5,
                                                              //  2: 4/6,
                                                              //  3: 4/7,
                                                              //  4: 4/8]
#define LORA_PREAMBLE_LENGTH                        8         // Same for Tx and Rx
#define LORA_SYMBOL_TIMEOUT                         0         // Symbols
#define LORA_FIX_LENGTH_PAYLOAD_ON                  false
#define LORA_IQ_INVERSION_ON                        false


#define RX_TIMEOUT_VALUE                            1000
#define BUFFER_SIZE                                 30 // Define the payload size here

char txpacket[BUFFER_SIZE];
char rxpacket[BUFFER_SIZE];

static RadioEvents_t RadioEvents;

int16_t txNumber;

int16_t rssi,rxSize;

bool lora_idle = true;
unsigned long lastRxTime = 0;
const unsigned long SIGNAL_TIMEOUT = 5000; // 5 seconds

void decryptAES(uint8_t *data, const char *key);
void encryptAES(uint8_t *data, const char *key);
void processKey(const char *userKey, uint8_t *processedKey, size_t keySize);

void setup() {
  Serial.begin(115200);
  Serial.println();
  Serial.println();
  VextON();
  delay(100);

  // Initialising the UI will init the display too.
  display.init();

  display.setFont(ArialMT_Plain_10);
  pinMode(triggerdOutputPin, OUTPUT);
  //LoRa stuff blow this line
     Mcu.begin(HELTEC_BOARD,SLOW_CLK_TPYE);
    
    txNumber=0;
    rssi=0;
  
    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 );
}


void displayTemperature(String data1, String data2) {

    display.clear();  // Clear display before new content
    
    // Line 1: "Temperature:" in 16pt font
    display.setTextAlignment(TEXT_ALIGN_LEFT);
    display.setFont(ArialMT_Plain_16);
    display.drawString(0, 0, data1);

    // Line 2: Temperature value in 24pt font
    display.setFont(ArialMT_Plain_24);
    display.drawString(0, 20, data2);  // 
    displaySignalStrength(rssi);
   // display.display();  // Update OLED

    
}

void displayLine(String data, int y) {
    // Line 1: "Temperature:" in 16pt font
    display.setTextAlignment(TEXT_ALIGN_LEFT);
    display.setFont(ArialMT_Plain_10);

    if (triggerdBlink4Me) {
        // Blink effect: Display text, wait, clear text, wait, then return
        display.drawString(0, y, data);
        display.display();
        delay(500);  // Keep text visible for 500ms

        display.clear();  // Clear the screen
        display.display();
        delay(500);  // Keep screen blank for 500ms
    } 
    else {
        // Normal display without blinking
        display.drawString(0, y, data);
        display.display();
    }
}


void VextON(void)
{
  pinMode(Vext,OUTPUT);
  digitalWrite(Vext, LOW);
}

void VextOFF(void) //Vext default OFF
{
  pinMode(Vext,OUTPUT);
  digitalWrite(Vext, HIGH);
}



void loop() {
  RaIrqProcessdio( );
  if(lora_idle)
  {
    lora_idle = false;
    Serial.println("into RX mode");
    Radio.Rx(0);
  }
  noSignalCheck();

  delay(100);

}

void displaySignalStrength(int16_t rssi) {
    // Convert RSSI to percentage (0-100%)
    int percent = map(constrain(rssi, MIN_RSSI, MAX_RSSI), MIN_RSSI, MAX_RSSI, 0, 100);
    
    // Display at bottom right corner
    display.setTextAlignment(TEXT_ALIGN_RIGHT);
    display.setFont(ArialMT_Plain_16);
    
    // Create signal strength indicator
    String strength = String(percent) + "% [";
    for (int i = 0; i < 5; i++) {
        strength += (percent > (i * 20)) ? "|" : " ";
    }
    strength += "]";
    
    display.drawString(128, 45, strength); // Position at bottom-right
}

void noSignalCheck()
{
    // Automatic "No Signal" after timeout
    if (millis() - lastRxTime > SIGNAL_TIMEOUT) {
        display.clear();
        display.setTextAlignment(TEXT_ALIGN_CENTER);
        display.setFont(ArialMT_Plain_16);        
        display.drawString(64, 20, "No Signal");
        display.display();
    }
}

/**
 * Triggers an action based on a threshold comparison.
 *
 * @param type           - If true, triggers when floatValue **exceeds** triggerdValue.
 *                         If false, triggers when floatValue **falls below** triggerdValue.
 * @param floatValue     - The current measured value to compare.
 * @param triggerdValue  - The threshold value that determines the trigger condition.
 */
void triggerAction(float floatValue)
{
  if(triggerdType)
  {
    if (floatValue > triggerdValue) {
        displayLine(triggerdText, triggerdYpos);
        Serial.println(triggerdText);
        digitalWrite(triggerdOutputPin, HIGH);//turns triggerdOutputPin to HIGH
    }else{
        digitalWrite(triggerdOutputPin, LOW);
    }
  }else{
    if (floatValue < triggerdValue) {
        displayLine(triggerdText, triggerdYpos);
        Serial.println(triggerdText);
        digitalWrite(triggerdOutputPin, HIGH);//turns triggerdOutputPin to HIGH
    } else{
        digitalWrite(triggerdOutputPin, LOW);//turns triggerdOutputPin to LOW
    }   
  }
}
void OnRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr )
{
    lastRxTime = millis(); // Reset timer on new data
    rssi=rssi;
    rxSize=size;
    memcpy(rxpacket, payload, size );

    rxpacket[size]='\0';
    Radio.Sleep( );
    Serial.printf("\r\nreceived packet \"%s\" with rssi %d , length %d\r\n",rxpacket,rssi,rxSize);
    // Serial.println("Encrypted Data (Hex):");
    // for (int i = 0; i < 16; i++) {
    //     Serial.printf("%02X ", rxpacket[i]);
    // }
    // Serial.println();
   decryptAES((uint8_t *)rxpacket, userKey);

    // Split the received packet into parts
    String receivedStr = String((char*)rxpacket);
    int firstSpacePos = receivedStr.indexOf(' ');
    if (firstSpacePos != -1) {
        // First part (before first space)
        String part1 = receivedStr.substring(0, firstSpacePos);  // "Temperature"
        
        // Find second space (after the number)
        int secondSpacePos = receivedStr.indexOf(' ', firstSpacePos + 1);
        
        if (secondSpacePos != -1) {
            // Second part (numeric value)
            String part2 = receivedStr.substring(firstSpacePos + 1, secondSpacePos); // "34.5"
            float floatValue = part2.toFloat();  // Convert to float 34.5
            
            // Third part (unit)
            String part3 = receivedStr.substring(secondSpacePos + 1); // "°C"
            
            displayTemperature(part1, part2+part3);
            display.display();
            Serial.print("part1: " + part1);
            Serial.print(" part2: " + part2);
            Serial.println(" part3: " + part3);
            Serial.println("floatValue " + String(floatValue));          
        
        //to trigger an action. 
        triggerAction(floatValue);

        } else {
            Serial.println("No second space found for unit");
        }
    }else {
        Serial.println("No space found in packet - can't split");
    }     


    lora_idle = true;
}

/**
 * Converts a user-provided plaintext key into a fixed-length 16-byte (128-bit)
 * or 32-byte (256-bit) key.
 */
void processKey(const char *userKey, uint8_t *processedKey, size_t keySize) {
    memset(processedKey, 0, keySize); // Fill with zeros
    size_t len = strlen(userKey);
    if (len > keySize) len = keySize; // Truncate if too long
    memcpy(processedKey, userKey, len); // Copy valid key part
}

/**
 * Encrypts a 16-byte (one block) message using AES-128.
 */
void encryptAES(uint8_t *data, const char *key) {
    uint8_t processedKey[16]; // 128-bit key
    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);
}

/**
 * Decrypts a 16-byte (one block) message using AES-128.
 */
void decryptAES(uint8_t *data, const char *key) {
    uint8_t processedKey[16]; // 128-bit key
    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

Robojax_HeltecLoRa32V3
Download

Recursos e referências

Externo
Compre o Wi-Fi LoRa 32 da Meshnology.
meshnology.com
Externo
Compre um WiFi LoRa 32 na Amazon Canadá.
amzn.to
Externo
Compre um WiFi LoRa 32 na Amazon dos EUA.
amzn.to
Externo
Compre um WiFi LoRa 32 na Amazon Europa
amzn.to
Externo
Compre uma capa WiFi LoRa 32 na Amazon dos EUA.
amzn.to

Arquivos📁

Outros arquivos

Diagrama Esquemático Heltec WiFi LoRa 32 V3 (V3.1)
Heltec_WiFiLoRAV3_Schematic_Diagram.pdf 0.18 MB

Próxima lição →

Usando o Heltec WiFi LoRa 32 V3 para transmitir temperatura usando DHT22 a 1,4 km.

Este tutorial faz parte de: Tutoriais WiFi LoRa 32

Usando o Heltec WiFi LoRa 32 V3 para transmitir temperatura usando DHT22 a 1,4 km.

Hardware Explicado

Detalhes da Ficha Técnica

Instruções de Fiação

Instalando placas Heltec ESP32

Exemplos de Código e Tutorial

Demonstração / O Que Esperar

Marcação de Tempo do Vídeo

Imagens

Este tutorial é parte de: Tutoriais WiFi LoRa 32

Common Course Links

Common Course Files

Recursos e referências

Arquivos📁

Outros arquivos

Produtos Relacionados da Amazon

HiLetgo 2pcs DHT22/AM2302 Digital Temperature and Humidity Sensor Module Temperature Humidity Monitor Sensor Replace SHT11 SHT15 for Arduino Electronic Practice DIY

SATUY 4Pcs DHT22/AM2302 Digital Temperature Humidity Sensor Module with Cable, Temp Range -40~80℃ (±0.5℃), Humidity 0~100% RH (±2%) for A-rduino Electronic Practice DIY, Replace SHT11 SHT15

6 Set Digital Temperature and Humidity Sensor Modules, Compatible with DHT22/AM2302, 3.3V–5V Sensors for Arduino with Dupont Wires

WWZMDiB 3Pcs DHT22/AM2302 Digital Temperature and Humidity Sensor Module Temperature Measure-40-80℃（±0.5℃） Humidity Measure 0%-100% RH（±2%） for Arduino DIY

MakerFocus ESP32 LoRa V3 Development Board with 915 MHz Antenna Integrated WiFi Bluetooth SX1262 CP2102 0.96-inch OLED Display Type C for Meshtastic IoT Arduino Intelligent Scenes

HiLetgo ESP32 V3 LoRa V3 SX1262 0.96 inch OLED Display Development Board WiFi Bluetooth Dual Core 240MHz CP2102 and 863-928MHz Antenna for Arduino Smart Home WiFi LoRa 32(Unsoldered)

LoRa V3 ESP32 LoRa V3 Development Board, SX1262 ESP32 V3 Dual-core OLED Type C WI-FI Kit OLED Display ESP32 Module CP2012 863-928 MHz for IOT Meshtastic Arduin0, 2-Pack

MakerFocus 2pcs ESP32 LoRa V3 Development Board with 915 MHz Antenna Integrated WiFi Bluetooth SX1262 CP2102 0.96-inch OLED Display Type C Interface for Meshtastic IoT Arduino Intelligent Scenes

Heltec ESP32 LoRa 32 V4 Development Board with OLED Display Upgraded ESP32 S3 SX1262 27dBm High Power Chip for WiFi Meshtastic IoT Devices Arduino Smart Home and Wireless Communication

Meshnology 2 Pack ESP 32 Lo Ra V3 Development Board + 1100mAh Battery + Protect Case Set - with 915MHz Antenna and SX 1262 Lo Ra V3 Devices for Mesh Tastic Ar duino Lo Rawan IoT (N30 Version, Black)

Heltec Wireless Bridge Point to Point Outdoor – WiFi Bridge 3300 feet Long-Range Transmission, 802.11ah WiFi HaLow Dongle with Atenna Ethernet Cable (AP+STA Pair Set)

2 Pack ESP 32 Lo Ra V3 Development Board + 1100mAh Battery + Protect Case Set - with 915MHz Antenna and SX 1262 Surport WiFi Blue Tooth Lo Ra V3 Devices for Meshtastic Ar duino LoRawan IOT

Meshnology Wio Tracker L1 Board with 3000mAh Battery and Case Set - SX1262 nRF52840 Kit for Ar duino Mesh Tastic Lo Ra, Blue Tooth 5.0, GPS GNSS, 1.3" OLED, Battery Type-C Solar Charge (N37, Purple)

Meshnology 2 Set ESP32 LoRa V3 Module Board with 915 MHz Antenna + 3000mAh Battery + Case - WiFi Blue Tooth SX1262 CP2102 0.96” OLED Display Type C for Ar duino Meshtastic IoT (N35, Green)

Meshnology ThinkNode M1 LoRa Meshtastic Device Integrated Design with GPS Bluetooth SX1262 nRF52840 1.54" E-Ink Display 915MHz Antenna 1200mAh Battery RTC Type-C Interface Multi-Functional Button

Meshnology ESP32 Lo Ra V3 Development Board + 1100mAh Battery + Case + USB Charger Cable Set - with 915MHz Antenna and SX1262 Lo Ra V3 Devices for Mesh Tastic Ar duino Lo Rawan IOT (N30,4-in-1,Black)

Meshnology 2 Pack Case for ESP32 LoRa V3 Module Board Device Antenna OLED Protection Case with Type C and Copper Tube Antenna Interface (N30 Version, Red)

Heltec V3 ESP32 LoRa Development Board with OLED Display Case N30 White and 800mAh Battery S3 SX1262 Support Meshtastic LoRaWAN WiFi Compatible Type-C USB IoT Node for Smart Home Industrial Control

Listagens relacionadas do eBay

DC5V WS2812B 5050 RGB Flexible LED Panel Matrix Display Screen Addressable Light

BRAND NEW For 2009-2012 DODGE RAM 1500 Clock Spring Angle Sensor Module

Red 5" Seven 7 Segment Display Common Anode LED Digital Number 1 Bit 10 pins DIP

ST N-CHANNEL MOSFET P4NK60Z STP4NK60Z 600V 4A 70W TO-220 USED IN VARIOUS APPS

Rotary Axis For 40W CO2 Laser Engravers with Nema17 2-Phase 4 Wire Stepper Motor

Produtos Relacionados do AliExpress

Pro Micro ATMEGA32U4 5V/16MHZ module With the bootloader for arduino MINI USB/Micro USB with 2 row pin header for arduino

8 Digit Bit MAX7219 Digital Tube Display Module Board 7 Segment Digital LED Display for 3.3V 5V STC51/AVR/STM32

LCD2004 IIC/I2C LCD Display Monitor 2004 20X4 5V Character Blue Backlight Screen LCD2004 IIC I2C for arduino LCD display

10PCS -20PCS JFAM20N65E TO-3P 20A 650V Fast Shipping Quality Guarantee

Hot Electric Windproof Metal Lighter Double Arc Flameless Plasma Rechargeable USB Lighter LED Power Display Touch Sensor Lighter

Etiquetas

Tutoriais Mais Recentes