Skip to main content

Unboxing & Configuring Heltec ESP32 V3 LoRa Boards – Easy Peer-to-Peer Communication Setup

 

LoRa (Long Range) is a wireless communication technology designed for long-distance, unlicensed frequency, low-power data transmission. It’s widely used in IoT (Internet of Things) applications where devices need to send small amounts of data over several kilometers without relying on Wi-Fi or cellular networks. With its low power consumption and extended range, LoRa is ideal for smart agriculture, environmental monitoring, and remote sensing projects.

In this guide, I’ll walk you through my LoRa implementation setup using the Heltec ESP32 V3 boards. If you haven’t already installed the Arduino IDE on your computer, make sure to install it first. it’s essential for uploading code to your LoRa boards.

Once the Arduino IDE is successfully installed, it should look like the screenshot below (or similar depending on your version). From there, follow the steps outlined in this tutorial to configure your boards for peer-to-peer communication.


For this project, I used two Heltec ESP32 V3 LoRa boards—one configured as a transmitter and the other as a receiver. These boards are among the most reliable development boards available, with built-in LoRa and OLED display features, making them ideal for peer-to-peer wireless communication.

Below, you can see the unboxed Heltec LoRa board packages, which include the boards, antennas, and USB cables required for setup.


When you unbox the Heltec ESP32 V3 LoRa board, you’ll typically find the following components included:
  • Heltec ESP32 V3 LoRa Board
  • LoRa Antenna
  • Antenna Extension Cable
  • Male Bus Bars (Header Pins)
  • Power Supply Connector

Once you’ve unboxed your Heltec ESP32 V3 LoRa board and its accessories, it's time to assemble and set up everything. In my setup, I didn’t use an external power supply instead, I powered the board directly from my computer using a USB-C cable.
To enable communication between the Heltec board and your computer, you need to add Heltec board support to the Arduino IDE and install the necessary drivers for serial communication.

How to Add the Heltec ESP32 Board to Arduino IDE:
In Arduino IDE 2.x: go to File > Preferences

Add Board Manager URL:
In the “Additional Board Manager URLs” field, paste the following URL:

Install Heltec ESP32 Board Package:
  • Go to Tools > Board > Boards Manager
  • Search for "Heltec ESP32"
  • Click Install on the Heltec ESP32 package (installation may take a few minutes)
Select Your Board:
After installation, go to Tools > Board and select: “Heltec WiFi LoRa 32 (V3)”

Board selection snapshot

To enable your computer to communicate with the Heltec ESP32 V3 LoRa boards over USB, you need to install the correct serial communication driver.

Step-by-Step Instructions:
1. Download the CP210x Driver:
Go to the official Silicon Labs website:
https://www.silabs.com/developer-tools/usb-to-uart-bridge-vcp-drivers?tab=downloads

2. Select & Install the Driver:
Download the “CP210x Windows Drivers” – it’s usually the fourth item in the list.
Once downloaded, run the installer and follow the on-screen instructions.

3. Restart Your Computer:
After installation, it's recommended to restart your PC to ensure the driver loads correctly.

4. Select the Correct COM Port in Arduino IDE:
  • Open Arduino IDE
  • Go to Tools > Port
  • Select the COM port associated with your Heltec board
💡 Tip: You can verify the correct COM port via Device Manager:

Open Device Manager
Look under “Ports (COM & LPT)”
You should see something like:
Silicon Labs CP210x USB to UART Bridge (COMX)


Device manage snapshot

Before you can fully use your Heltec board, you’ll need to activate it the first time you connect it to your computer. This step ensures that the board is registered and ready for development.

Activation Steps:
  1. Connect your Heltec board to your computer using the USB-C cable.
  2. Open your browser and visit the official Heltec activation page: https://resource.heltec.cn/search
  3. On the page, enter the serial number of your board (usually printed on the back of the board or its packaging).
  4. Click the "Confirm" button.
  5. Once verified, you should see your board’s information and status displayed on the screen.

Activating the License Key via AT Command
During the activation process, you'll notice a 32-character license key displayed in the License column as above page. This key is required to register your board with the Heltec system.

Format of the License Key Command
You need to use this license key to send an AT command to the board. The correct format is:
AT+CDKEY=AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDD

⚠️ Note: Replace AAAAAAAABBBBBBBBCCCCCCCCDDDDDDDD with the actual 32-character key shown on the Heltec website.

Sending the License Key via Arduino IDE
  1. Open the Serial Monitor in Arduino IDE.
  2. Paste the full AT+CDKEY=... line into the input/message field.
  3. Make sure the baud rate is set to the correct value (usually 115200).
  4. Press Enter to send the command to the board.
  5. Once successfully entered, the board will confirm the license activation.

Once you've successfully entered the license key using the AT+CDKEY=... command, your Heltec LoRa board is now activated and ready to use. You can now use the board according to your project requirements, including transmitting and receiving data via LoRa communication.
For my initial test, I used a simple example sketch provided by the official Heltec ESP32 library WiFi_LoRa_32_V3_FactoryTest. This basic program is great for verifying that your board is working correctly and that the LoRa features are functional.

/*
 * HelTec Automation(TM) WIFI_LoRa_32 factory test code, witch include
 * follow functions:
 *
 * - Basic OLED function test;
 *
 * - Basic serial port test(in baud rate 115200);
 *
 * - LED blink test;
 *
 * - WIFI connect and scan test;
 *
 * - LoRa Ping-Pong test (DIO0 -- GPIO26 interrup check the new incoming messages);
 *
 * - Timer test and some other Arduino basic functions.
 *
 * by Aaron.Lee from HelTec AutoMation, ChengDu, China
 * 成都惠利特自动化科技有限公司
 * https://heltec.org
 *
 * this project also realess in GitHub:
 * https://github.com/HelTecAutomation/Heltec_ESP32
*/

#include "Arduino.h"
#include "WiFi.h"
#include "images.h"
#include "LoRaWan_APP.h"
#include <Wire.h>  
#include "HT_SSD1306Wire.h"
/********************************* lora  *********************************************/
#define RF_FREQUENCY                                868000000 // Hz

#define TX_OUTPUT_POWER                             10        // 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;
void OnTxDone( void );
void OnTxTimeout( void );
void OnRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr );

typedef enum
{
    LOWPOWER,
    STATE_RX,
    STATE_TX
}States_t;

int16_t txNumber;
int16_t rxNumber;
States_t state;
bool sleepMode = false;
int16_t Rssi,rxSize;

String rssi = "RSSI --";
String packSize = "--";
String packet;
String send_num;
String show_lora = "lora data show";

unsigned int counter = 0;
bool receiveflag = false; // software flag for LoRa receiver, received data makes it true.
long lastSendTime = 0;        // last send time
int interval = 1000;          // interval between sends
uint64_t chipid;
int16_t RssiDetection = 0;


void OnTxDone( void )
{
  Serial.print("TX done......");
  state=STATE_RX;

}

void OnTxTimeout( void )
{
  Radio.Sleep( );
  Serial.print("TX Timeout......");
  state=STATE_TX;
}

void OnRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr )
{
  rxNumber++;
  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("wait to send next packet");
  receiveflag = true;
  state=STATE_TX;
}


void lora_init(void)
{
  Mcu.begin(HELTEC_BOARD,SLOW_CLK_TPYE);
  txNumber=0;
  Rssi=0;
  rxNumber = 0;
  RadioEvents.TxDone = OnTxDone;
  RadioEvents.TxTimeout = OnTxTimeout;
  RadioEvents.RxDone = OnRxDone;

  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 );

  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 );
  state=STATE_TX;
}


/********************************* lora  *********************************************/

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


void logo(){
  factory_display.clear();
  factory_display.drawXbm(0,5,logo_width,logo_height,(const unsigned char *)logo_bits);
  factory_display.display();
}

void WIFISetUp(void)
{
  // Set WiFi to station mode and disconnect from an AP if it was previously connected
  WiFi.disconnect(true);
  delay(100);
  WiFi.mode(WIFI_STA);
  WiFi.setAutoReconnect(true);
  WiFi.begin("Galaxya72","mobitelqw");//fill in "Your WiFi SSID","Your Password"
  delay(100);

  byte count = 0;
  while(WiFi.status() != WL_CONNECTED && count < 10)
  {
    count ++;
    delay(500);
    factory_display.drawString(0, 0, "Connecting...");
    factory_display.display();
  }

  factory_display.clear();
  if(WiFi.status() == WL_CONNECTED)
  {
    factory_display.drawString(0, 0, "Connecting...OK.");
    factory_display.display();
//    delay(500);
  }
  else
  {
    factory_display.clear();
    factory_display.drawString(0, 0, "Connecting...Failed");
    factory_display.display();
    //while(1);
  }
  factory_display.drawString(0, 10, "WIFI Setup done");
  factory_display.display();
  delay(500);
}

void WIFIScan(unsigned int value)
{
  unsigned int i;
    WiFi.mode(WIFI_STA);

  for(i=0;i<value;i++)
  {
    factory_display.drawString(0, 20, "Scan start...");
    factory_display.display();

    int n = WiFi.scanNetworks();
    factory_display.drawString(0, 30, "Scan done");
    factory_display.display();
    delay(500);
    factory_display.clear();

    if (n == 0)
    {
      factory_display.clear();
      factory_display.drawString(0, 0, "no network found");
      factory_display.display();
      //while(1);
    }
    else
    {
      factory_display.drawString(0, 0, (String)n);
      factory_display.drawString(14, 0, "networks found:");
      factory_display.display();
      delay(500);

      for (int i = 0; i < n; ++i) {
      // Print SSID and RSSI for each network found
        factory_display.drawString(0, (i+1)*9,(String)(i + 1));
        factory_display.drawString(6, (i+1)*9, ":");
        factory_display.drawString(12,(i+1)*9, (String)(WiFi.SSID(i)));
        factory_display.drawString(90,(i+1)*9, " (");
        factory_display.drawString(98,(i+1)*9, (String)(WiFi.RSSI(i)));
        factory_display.drawString(114,(i+1)*9, ")");
        //factory_display.println((WiFi.encryptionType(i) == WIFI_AUTH_OPEN)?" ":"*");
        delay(10);
      }
    }

    factory_display.display();
    delay(800);
    factory_display.clear();
  }
}

bool resendflag=false;
bool deepsleepflag=false;
bool interrupt_flag = false;
void interrupt_GPIO0()
{
  interrupt_flag = true;
}
void interrupt_handle(void)
{
  if(interrupt_flag)
  {
    interrupt_flag = false;
    if(digitalRead(0)==0)
    {
      if(rxNumber <=2)
      {
        resendflag=true;
      }
      else
      {
        deepsleepflag=true;
      }
    }
  }

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

void VextOFF(void) //Vext default OFF
{
  pinMode(Vext,OUTPUT);
  digitalWrite(Vext, HIGH);
}
void setup()
{
  Serial.begin(115200);
  VextON();
  delay(100);
  factory_display.init();
  factory_display.clear();
  factory_display.display();
  logo();
  delay(300);
  factory_display.clear();

  WIFISetUp();
  WiFi.disconnect(); //
  WiFi.mode(WIFI_STA);
  delay(100);

  WIFIScan(1);

  chipid=ESP.getEfuseMac();//The chip ID is essentially its MAC address(length: 6 bytes).
  Serial.printf("ESP32ChipID=%04X",(uint16_t)(chipid>>32));//print High 2 bytes
  Serial.printf("%08X\n",(uint32_t)chipid);//print Low 4bytes.

  attachInterrupt(0,interrupt_GPIO0,FALLING);
  lora_init();
  packet ="waiting lora data!";
  factory_display.drawString(0, 10, packet);
  factory_display.display();
  delay(100);
  factory_display.clear();
  pinMode(LED ,OUTPUT);
  digitalWrite(LED, LOW);  
}


void loop()
{
interrupt_handle();
 if(deepsleepflag)
 {
  VextOFF();
  Radio.Sleep();
  SPI.end();
  pinMode(RADIO_DIO_1,ANALOG);
  pinMode(RADIO_NSS,ANALOG);
  pinMode(RADIO_RESET,ANALOG);
  pinMode(RADIO_BUSY,ANALOG);
  pinMode(LORA_CLK,ANALOG);
  pinMode(LORA_MISO,ANALOG);
  pinMode(LORA_MOSI,ANALOG);
  esp_sleep_enable_timer_wakeup(600*1000*(uint64_t)1000);
  esp_deep_sleep_start();
 }

 if(resendflag)
 {
  state = STATE_TX;
  resendflag = false;
 }

if(receiveflag && (state==LOWPOWER) )
{
  receiveflag = false;
  packet ="R_data:";
  int i = 0;
  while(i < rxSize)
  {
    packet += rxpacket[i];
    i++;
  }
  packSize = "R_Size: ";
  packSize += String(rxSize,DEC);
  packSize += " R_rssi: ";
  packSize += String(Rssi,DEC);
  send_num = "send num: ";
  send_num += String(txNumber,DEC);
  factory_display.drawString(0, 0, show_lora);
  factory_display.drawString(0, 10, packet);
  factory_display.drawString(0, 20, packSize);
  factory_display.drawString(0, 50, send_num);
  factory_display.display();
  delay(10);
  factory_display.clear();

  if((rxNumber%2)==0)
  {
   digitalWrite(LED, HIGH);  
  }
}
switch(state)
  {
    case STATE_TX:
      delay(1000);
      txNumber++;
      sprintf(txpacket,"hello %d,Rssi:%d",txNumber,Rssi);
      Serial.printf("\r\nsending packet \"%s\" , length %d\r\n",txpacket, strlen(txpacket));
      Radio.Send( (uint8_t *)txpacket, strlen(txpacket) );
      state=LOWPOWER;
      break;
    case STATE_RX:
      Serial.println("into RX mode");
      Radio.Rx( 0 );
      state=LOWPOWER;
      break;
    case LOWPOWER:
      Radio.IrqProcess( );
      break;
    default:
      break;
  }
}

Comments

Post a Comment

Most Popular Topics

ESP32 with Neo-6M GPS Module: Hardware Serial Code & Practical Implementation Guide

In this project, I used the ESP32 WROOM-32 development board in combination with the Neo-6M GPS module to acquire real-time satellite-based location data. The hardware components were interconnected using hardware serial (UART) to ensure reliable communication between the ESP32 and the GPS module. The wiring setup is illustrated below. Neo-6M GPS Module     |      ESP32 WROOM-32        Vcc      =====>   VIN (3.3V) GND   =====>     GND     TX      =====>    GPIO16     RX     =====>   GPIO17 Snapshot of the NEO-6M GPS Module used in this project: Front View of the NEO-6M GPS Module Backside of the NEO-6M GPS Module Snapshot of the ESP32 WROOM-32 Arduino board used in this project: After the interconnecting these two boards you have to follow following procedures. Install TinyGPS++ library: Open Ardui...
Post a Comment
Read more

How to Design and Simulate a 4-Phase Interleaved Boost Converter Using MATLAB Simulink

In this case study, I investigate the performance of a 4-phase interleaved boost converter using MATLAB Simulink. This type of DC-DC converter architecture is widely used in high-efficiency power systems due to its improved current sharing and reduced output ripple. Each phase of the converter is symmetrically designed using identical passive components: Inductors: L₁ = L₂ = L₃ = L₄ = 1.5 mH Capacitors: C₁ = C₂ = 200 μF The converter supplies an inductive load that draws a constant output current of 5 A. The input voltage is fixed at 30 V, and the converter is operated at a duty cycle (D) of 0.6. The primary simulation objectives are to analyze: The voltage gain of the converter, The output voltage ripple characteristics, And the phase current sharing behavior under these operating conditions. Simulink design of 4-phase interleaved boost converter Simulink inputs and output of design Through this design and simulation, the following steady state waveforms can be evaluated: Load voltage...
Post a Comment
Read more

Monitor Docker Services Using Grafana, Prometheus & cAdvisor — Without Touching the CLI

  If you're running Docker containers on a server, monitoring their performance using command-line tools can be time-consuming and difficult to visualize. In this guide, I’ll show you how to monitor your Docker services using Grafana, Prometheus, and cAdvisor—all through a web interface, without relying on CLI tools after setup. You’ll be able to: Track real-time Docker container metrics Visualize system performance through a Grafana dashboard Use Prometheus to scrape and expose container metrics Deploy everything using simple Docker commands Step 1: Run Your Docker Containers Make sure your Docker containers are already running. Here’s a snapshot of my currently active containers: Step 2: Install cAdvisor in a Docker Container To collect container metrics in real time, we’ll run cAdvisor inside a dedicated Docker container. Run the cAdvisor Container: sudo docker run   --volume=/:/rootfs:ro   --volume=/var/run:/var/run:rw   --volume=/sys:/sys:ro   --volume=/var...
Post a Comment
Read more

Scientific Writing - Research Article

  Significant sections of the Research Article How to write an Abstract? The abstract section is very important for the scientific paper because it represents all the contents briefly of a paper and the reader will decide whether or not to read the whole article. This is written by summarizing the introduction section. It has to briefly include the  problem, method, findings, and conclusion usually in the factual or past tense. How to write an Introduction? Start with a broad overview of the research scope. You have to provide a general background of the field or topic. Then you write a  literature survey about the topic. It does a critical analysis of the existing research on a specific topic. The next step is explaining a problem statement or research gaps . Then you can be writing  research objectives to provide the solution to the given problem statement or research gaps. Finally write scope and limitations that explain how the limitations may have affec...
Post a Comment
Read more

Partitioning hard drives in Linux servers

ADDING PARTITIONS, FILE SYSTEMS, AND PERSISTENT MOUNTS The following flow chart indicates adding partitioning, file systems, and creating mount points for partitioning on Linux systems in a very short format and this is able to understand easily the complex process of Linux storage management. LOGICAL VOLUME MANAGEMENT (LVM) CONCEPTS The following flow chart indicates the LVM concepts very shortly on Linux systems.
Post a Comment
Read more

Different dates data plot on common x axis in 24-hour time frame using python.

Here, I used a different method to represent hourly data across various dates. I converted specific dates to common dates and then plotted the time series data on a 24-hour time frame along the x-axis, with traffic patterns on the y-axis.  import os import pandas as pd import numpy as np import matplotlib.pyplot as plt from datetime import datetime import matplotlib.dates import matplotlib.dates as md path = 'datasheet.csv' data = pd.read_csv(path) data.head() # Convert data to DataFrame df = pd.DataFrame({'Date&Time': data['Date'] , 'DL': data['DL']/1000000000, 'UL': data['UL']/1000000000}) # Replace all Date&Time with '02/02/2024' df['Date&Time'] = '02/02/2024 ' + df['Date&Time'].str.split(' ', expand=True)[1] # Convert 'Date&Time' column to datetime format df['Formated_Date'] = pd.to_datetime(df['Date&Time'], format='%m/%d/%Y %H:%M...
Post a Comment
Read more

The Example two story house project scheduling in Project Management

First, we must identify the various activities that must be carried out in constructing a two-story house and group them into suitable work breakdown structures (WBS). The following figure indicates the WBS of this sample project and appropriate implementation periods for each activity. Note that the project has to complete within 12 months as a condition. Therefore, we have to be very careful when scheduling the duration of activities in order to complete the project on time. The next step is to build a project using a computer program. Here I used MS Project software and the following figure shows the Project plan and the status of activities completed. The red color activities and arrows indicate the critical path of the project. Path activities have to be completed between the exact period in order to hand over the project on time.
Post a Comment
Read more

Innovative AI Frameworks for Controlling Plant Growth Parameters

Food is a fundamental necessity for human survival, leading to the expansion of crop cultivation beyond traditional rural areas into urban environments. Urban farming presents several advantages, including access to fresh, organic produce and the creation of new job opportunities. However, despite these benefits, urban agriculture faces notable challenges. Organic foods are often more expensive, and the success of urban farming initiatives can be hampered by insufficient space for plant growth, insufficient knowledge, inadequate conditions for plant growth, and significant environmental changes driven by global development. To address these challenges, this research focuses on leveraging Artificial Intelligence (AI) techniques to enhance urban farming practices. By applying AI, it is possible to optimize growing conditions, predict and manage plant needs, and adapt to changing environmental factors. AI can also help streamline operations and reduce costs, making urban farming more viab...
Post a Comment
Read more

How to Create a Share Folder Between Virtual Machine and Host Computer

  In this episode, I’m going to guide you through the process of creating a shared folder between your host computer and a virtual machine (VM). This is a common challenge, as many people struggle with sharing files seamlessly between their host system and a VM. To address this issue, I’ll be demonstrating how to set up a shared folder using VMware Workstation Player, which will allow you to access files from both the host computer and the virtual machine. Having a shared folder is particularly useful for Linux beginners who are working on their lessons or projects within a virtual environment. By creating this shared folder, you’ll have a convenient way to transfer files, collaborate across different systems, and keep your work organized. This setup not only simplifies the process of file sharing but also enhances your workflow, as you won’t need to rely on external drives or other complicated methods to move files between the host and the VM. Moreover, we’ll be using this shared ...
Post a Comment
Read more