Reyax RYLR993-Lite LoRa Real-World Range Test – How Far Can It Really Go?

23 Views, 1 Favorites, 0 Comments

Reyax RYLR993-Lite LoRa Real-World Range Test – How Far Can It Really Go?

Can This REYAX RYLR993-Lite LoRa Reach 20 KM? | REYAX LoRa Range Test #rf #arduinoproject #antenna

A few days ago, I received a parcel from REYAX Technology containing a pair of RYLR993-Lite LoRa modules. The very first thing I wanted to do with these modules was to test their real-world maximum range.

In this Instructable, I’m going to share the complete hardware setup, circuit diagram, code, test method, and of course the real results of this range test. Many LoRa modules claim very long ranges on paper, but the actual performance in real outdoor conditions can be quite different — so this experiment is focused on practical, real-world testing.

I have also made a detailed YouTube video where I had documented the entire range test process, explained the circuit, and walked through the code step by step. You can watch the full video here:

👉 https://youtu.be/WhbwaZdS-xsSo

without any further delay, let’s start the project.

Supplies

For this project, I used the following components:

1. REYAX RYLR993-Lite LoRa Module – 2 pcs

2. Arduino Nano or Arduino Uno – 2 pcs

3. Breadboard – 2 pcs

4. 4-Channel Logic Level Shifter Module – 2 pcs

5. AMS1117 3.3V Voltage Regulator Module – 1 pc

6. LED – 1 pc

7. 220 Ω or 330 Ω Resistor – 1 pc

8. SD Card Module with SD Card – 1 set

9. Jumper Wires – as required

10. Arduino Programming Cable (USB) – 1 or 2 pcs

11. 7–12V Battery or Power Supply – 1 or 2 pcs

Schematic-

All the connections are clearly shown in the schematic. In my YouTube video, I have explained both the schematic and the Arduino code in detail. So, if you face any issues, you can watch the full video on my AkashWave RF YouTube channel — link: https://youtu.be/WhbwaZdS-xs

Just follow the schematic to build the circuit on a breadboard or prototype board. Here, I’m going to discuss some key points of this schematic you should remember .

The transmitter and receiver circuits are exactly the same. The only difference is that the receiver has an optional SD card module, which is not required for the transmitter.
The UART pins of this LoRa module are only 3.3V tolerant. So, if you are using a microcontroller that works on 5V logic, you must use a logic level shifter; otherwise, the LoRa module may get damaged.
If you use microcontrollers like ESP32, ESP8266, STM32, or Raspberry Pi Pico, which operate on 3.3V logic, then no logic level shifter is needed.
This LoRa module works on 3.3V and draws around 140 mA during transmission. The Arduino Nano’s onboard 3.3V regulator may not be able to supply enough current, so I used an AMS1117 3.3V linear regulator to power the LoRa module from the Arduino’s 5V output.
A linear regulator is preferred here because cheap SMPS buck converters can introduce RF and power supply noise, which may disturb the LoRa’s operation.
For the receiver circuit, I didn’t use any external 3.3V regulator because, during reception, the module does not draw a significant amount of current. The Arduino Nano’s onboard 3.3V regulator is sufficient in this case. That’s why, in the receiver circuit, I powered the LoRa module directly from the Arduino’s 3.3V pin.
The SD card module is completely optional in this project. The LED will indicate whether any data is being received. You can also use a USB data cable or an HC-05 Bluetooth module to view the incoming data along with its RSSI and SNR on the Serial Monitor or a mobile Bluetooth terminal app.
You only need the SD card module if you want to record the received data and signal report for later analysis. Otherwise, not using the SD card will not affect the normal operation of the code or the device.
My SD card module is 5V tolerant. If your module is not, please use a logic level shifter here as well; otherwise, it may get damaged.

Arduino Code-

You can download both the Arduino Codes and the Schematic PDF from here-

📄 Arduino Test Code & Circuit Diagram Download:

➡️ https://drive.google.com/drive/folders/1CgeTjTDF33mUT4Aev_M1TIqTufGyYMC2?usp=drive_link

I have already explained the complete Arduino code in detail in my YouTube video for a better and more in-depth understanding, so I won’t repeat every small detail here. If you want a full walkthrough of how the code works, I highly recommend watching that video.

Below, I’m sharing both the transmitter and receiver Arduino codes used in this project. After that, I will briefly explain some of the most important lines and settings that are critical for the proper working of the Reyax RYLR993-Lite LoRa module.

Transmitter code:

-------------------------------------------------------------

Project : Reyax RYLR993_Lite LoRa Counter (Transmitter)

Author : Akash Bag (VU3HAX) | AkashWave RF

Platform : Arduino (UNO / Nano / Pico / etc.)

Module : Reyax RYLR993 / RYLR993_Lite

-------------------------------------------------------------

Description:

------------

This sketch transmits an increasing counter value using the

Reyax RYLR993 LoRa module via AT commands (NEW firmware format).

The counter is sent periodically over LoRa in P2P mode.

This code is written in a clear and beginner-friendly way

for learning AT command based LoRa communication.

-------------------------------------------------------------

YouTube : https://www.youtube.com/@AkashWaveRF

-------------------------------------------------------------

#include <SoftwareSerial.h>

// --------------------------------------------------

// LoRa SoftwareSerial pin definitions

// --------------------------------------------------

// Arduino pin 7 = RX (from LoRa TX)

// Arduino pin 8 = TX (to LoRa RX)

#define LORA_RX_PIN 7

#define LORA_TX_PIN 8

// Create SoftwareSerial named "LoRa"

SoftwareSerial LoRa(LORA_RX_PIN, LORA_TX_PIN);

// --------------------------------------------------

// Green LED pin

// --------------------------------------------------

int ledPin = 5;

// --------------------------------------------------

// Counter that we will send: 1,2,3,4,5...

// --------------------------------------------------

unsigned long counter = 1;

void setup()

{

// Set LED pin as output

pinMode(ledPin, OUTPUT);

digitalWrite(ledPin, LOW);

// Start USB Serial (for debugging)

Serial.begin(9600);

// Start LoRa serial

LoRa.begin(9600);

delay(1500); // Give time for module to boot

Serial.println("======================================");

Serial.println("RYLR993 P2P LORA TRANSMITTER (NEW FW)");

Serial.println("======================================");

// --------------------------------------------------

// Basic test: check if module is alive

// --------------------------------------------------

LoRa.println("AT");

delay(300);

// --------------------------------------------------

// Reset the module

// --------------------------------------------------

LoRa.println("ATZ");

delay(2000);

// --------------------------------------------------

// Set Proprietary P2P mode

// 0 = LoRaWAN

// 1 = Proprietary

// --------------------------------------------------

LoRa.println("AT+OPMODE=1");

delay(300);

// IMPORTANT: After changing OPMODE, module must be reset

LoRa.println("ATZ");

delay(2000);

// --------------------------------------------------

// Set RF Band (Region)

// 7 = IN865 (India)

// --------------------------------------------------

LoRa.println("AT+BAND=865000000");

delay(300);

// Reset again to be safe

LoRa.println("ATZ");

delay(2000);

// --------------------------------------------------

// Set LoRa parameters

// Format: AT+PARAMETER=SF,BW,CR,CRC

// SF: 7 to 12

// BW: 125 / 250 / 500

// CR: 1=4/5, 2=4/6, 3=4/7, 4=4/8

// CRC: 1=OFF, 4=ON

// --------------------------------------------------

LoRa.println("AT+PARAMETER=10,125,1,4");

delay(300);

// --------------------------------------------------

// Set RF output power

// Range: 0 to 22 dBm

// --------------------------------------------------

LoRa.println("AT+CRFOP=22");

delay(300);

// --------------------------------------------------

// Set THIS device address = 1

// --------------------------------------------------

LoRa.println("AT+ADDRESS=1");

delay(300);

// --------------------------------------------------

// Set network ID (must be SAME on RX)

// --------------------------------------------------

LoRa.println("AT+NETWORKID=18");

delay(300);

// --------------------------------------------------

// Ask module UID (just for info)

// --------------------------------------------------

LoRa.println("AT+UID?");

delay(300);

Serial.println("======================================");

Serial.println("LORA CONFIGURATION DONE (TX)");

Serial.println("Band = IN865");

Serial.println("SF = 10, BW = 125kHz, CR = 4/5");

Serial.println("Power = 22 dBm");

Serial.println("Address = 1");

Serial.println("======================================");

}

void loop()

{

// --------------------------------------------------

// We will send the counter using NEW Reyax format:

// AT+SEND=DEST,LEN,DATA

// --------------------------------------------------

Serial.print("Sending counter = ");

Serial.println(counter);

// Convert counter to String so we can count digits

String payload = String(counter);

// Calculate payload length (number of characters)

int payloadLen = payload.length();

// Build and send command:

// Example: AT+SEND=2,3,134

LoRa.print("AT+SEND=2,"); // 2 = receiver address

LoRa.print(payloadLen); // LEN

LoRa.print(","); // comma

LoRa.println(payload); // DATA

// --------------------------------------------------

// Blink LED for 75 ms to indicate transmission

// --------------------------------------------------

digitalWrite(ledPin, HIGH);

delay(75);

digitalWrite(ledPin, LOW);

// --------------------------------------------------

// Print whatever module replies (optional debug)

// --------------------------------------------------

delay(300);

while (LoRa.available())

{

char c = LoRa.read();

Serial.write(c);

}

// --------------------------------------------------

// Increase counter

// --------------------------------------------------

counter++;

// --------------------------------------------------

// Wait 1 second before next transmission

// --------------------------------------------------

delay(1000);

}

This Arduino sketch configures a Reyax RYLR993_Lite LoRa module in P2P mode and then sends an increasing counter value (1, 2, 3, 4, …) wirelessly every second using AT commands. Each transmission blinks an LED and prints the module response on the Serial Monitor, so you can easily verify that data is being sent correctly.

Key Points-

LoRa.println("AT+BAND=865000000"); This line of code defines the operating frequency of the LoRa module. The Reyax RYLR993-Lite can operate roughly between 820 MHz and 960 MHz, but you must set the frequency according to the legal ISM band allowed in your country. In my case, the legal LoRa band is 865 MHz, so I have set the frequency value to: 865000000. Always make sure to check and follow your local radio regulations before choosing the frequency.
LoRa.println("AT+ADDRESS=1"); This line of code sets the address of the LoRa module. When transmitting data, you must also specify the destination module’s address. If the transmitter sends data to an address that does not match the receiver’s address, the receiver will not receive any data at all. So, both the transmitter and receiver addresses must be configured correctly for proper communication.
LoRa.print("AT+SEND=2,"); // 2 = receiver address, This line tells the transmitter LoRa module which receiver address it should send the data to. In this case, the value 2 is the address of the receiver module.

Receiver code:

-------------------------------------------------------------

Project : Reyax RYLR993_Lite LoRa Counter (Receiver)

Author : Akash Bag (VU3HAX) | AkashWave RF

Platform : Arduino (UNO / Nano / etc.)

Module : Reyax RYLR993 / RYLR993_Lite

-------------------------------------------------------------

Description:

------------

This sketch receives data from Reyax RYLR993 LoRa module

and displays it on Serial Monitor along with RSSI and SNR.

It also logs the received data into an SD card if SD card

is detected at startup.

-------------------------------------------------------------

YouTube : https://www.youtube.com/@AkashWaveRF

-------------------------------------------------------------

#include <SoftwareSerial.h>

#include <SPI.h>

#include <SD.h>

// --------------------------------------------------

// LoRa SoftwareSerial pin definitions

// --------------------------------------------------

#define LORA_RX_PIN 7 // Arduino receives data from LoRa module

#define LORA_TX_PIN 8 // Arduino sends data to LoRa module

// Create SoftwareSerial named "LoRa"

SoftwareSerial LoRa(LORA_RX_PIN, LORA_TX_PIN);

// --------------------------------------------------

// SD card settings

// --------------------------------------------------

#define SD_CS_PIN 10 // SD card CS pin

bool sdAvailable = false; // Will be true if SD card is detected

File logFile; // File object

// --------------------------------------------------

// Green LED pin

// --------------------------------------------------

int ledPin = 5;

// Time when last packet was received

unsigned long lastReceiveTime = 0;

// Variables to store received data, RSSI and SNR

String receivedData = "";

int receivedRSSI = 0;

int receivedSNR = 0;

// Log line counter

unsigned long logCounter = 1;

void setup()

{

pinMode(ledPin, OUTPUT);

digitalWrite(ledPin, LOW);

// Start USB Serial for debugging

Serial.begin(9600);

// Start LoRa serial

LoRa.begin(9600);

delay(1000);

Serial.println("======================================");

Serial.println("RYLR993 P2P LORA RECEIVER");

Serial.println("======================================");

// --------------------------------------------------

// Initialize SD card

// --------------------------------------------------

Serial.println("Initializing SD card... ");

if (SD.begin(SD_CS_PIN))

{

Serial.println("SD card detected!");

sdAvailable = true;

// Open or create the log file

logFile = SD.open("LORA_LOG.TXT", FILE_WRITE);

if (logFile)

{

// Write a nice header

logFile.println("==============================================");

logFile.println(" RYLR993_Lite Receiver Logger - AkashWave RF ");

logFile.println("==============================================");

logFile.println("Format:");

logFile.println("No, Received Data, RSSI (dBm), SNR (dB)");

logFile.println("----------------------------------------------");

logFile.flush(); // Make sure data is written to SD

}

else

{

Serial.println("Failed to open log file!");

sdAvailable = false;

}

else

{

Serial.println("SD card NOT detected!");

sdAvailable = false;

}

// --------------------------------------------------

// Check LoRa module

// --------------------------------------------------

LoRa.println("AT");

delay(300);

// --------------------------------------------------

// Reset module

// --------------------------------------------------

LoRa.println("ATZ");

delay(2000);

// --------------------------------------------------

// Set Proprietary mode

// --------------------------------------------------

LoRa.println("AT+OPMODE=1");

delay(300);

// Reset again

LoRa.println("ATZ");

delay(2000);

// --------------------------------------------------

// Set same frequency as TX

// --------------------------------------------------

LoRa.println("AT+BAND=865000000");

delay(300);

// --------------------------------------------------

// Set same LoRa parameters as TX

// --------------------------------------------------

LoRa.println("AT+PARAMETER=10,125,1,4");

delay(300);

// --------------------------------------------------

// Set RF power (not very important for RX, but keep same)

// --------------------------------------------------

LoRa.println("AT+CRFOP=22");

delay(300);

// --------------------------------------------------

// Set THIS device address = 2

// --------------------------------------------------

LoRa.println("AT+ADDRESS=2");

delay(300);

// --------------------------------------------------

// Set same network ID as TX

// --------------------------------------------------

LoRa.println("AT+NETWORKID=18");

delay(300);

// --------------------------------------------------

// Ask UID

// --------------------------------------------------

LoRa.println("AT+UID?");

delay(300);

Serial.println("======================================");

Serial.println("LORA CONFIGURATION DONE (RX)");

Serial.println("Waiting for packets...");

Serial.println("======================================");

}

void loop()

{

// --------------------------------------------------

// If something comes from LoRa module

// --------------------------------------------------

if (LoRa.available())

{

// Read one full line from module

String line = LoRa.readStringUntil('\n');

line.trim();

// Reyax sends:

// +RCV=ADDRESS,LEN,DATA,RSSI,SNR

// Example:

// +RCV=1,3,123,-45,10

if (line.startsWith("+RCV="))

{

Serial.println("----------------------------------");

Serial.print("Raw: ");

Serial.println(line);

// --------------------------------------------------

// Now we will extract DATA, RSSI and SNR from this line

// --------------------------------------------------

// Remove "+RCV=" from beginning

line.remove(0, 5);

// Now the string looks like:

// 1,3,123,-45,10

// Find positions of commas

int p1 = line.indexOf(','); // after ADDRESS

int p2 = line.indexOf(',', p1 + 1); // after LEN

int p3 = line.indexOf(',', p2 + 1); // after DATA

int p4 = line.indexOf(',', p3 + 1); // after RSSI

// Extract individual parts

String senderAddress = line.substring(0, p1); // not used, but extracted

String dataLength = line.substring(p1 + 1, p2); // not used, but extracted

receivedData = line.substring(p2 + 1, p3); // DATA

String rssiString = line.substring(p3 + 1, p4); // RSSI as string

String snrString = line.substring(p4 + 1); // SNR as string

// Convert RSSI and SNR to integer values

receivedRSSI = rssiString.toInt();

receivedSNR = snrString.toInt();

// --------------------------------------------------

// Now print them nicely

// --------------------------------------------------

Serial.print("Received: ");

Serial.println(receivedData);

Serial.print("RSSI: ");

Serial.print(receivedRSSI);

Serial.println(" dBm");

Serial.print("SNR: ");

Serial.print(receivedSNR);

Serial.println(" dB");

// --------------------------------------------------

// Log to SD card if available

// --------------------------------------------------

if (sdAvailable && logFile)

{

logFile.print(logCounter);

logFile.print(", Received: ");

logFile.print(receivedData);

logFile.print(", RSSI: ");

logFile.print(receivedRSSI);

logFile.print(", SNR: ");

logFile.println(receivedSNR);

logFile.flush(); // Ensure data is written

logCounter++;

}

// Turn LED ON because data is coming

digitalWrite(ledPin, HIGH);

// Save time of last reception

lastReceiveTime = millis();

}

// --------------------------------------------------

// If no data received for more than 3 seconds

// Turn LED OFF

// --------------------------------------------------

if (millis() - lastReceiveTime > 3000)

{

digitalWrite(ledPin, LOW);

}

This Arduino sketch configures another Reyax RYLR993_Lite module as a LoRa receiver using the same frequency and radio settings as the transmitter. It continuously listens for incoming packets sent by the transmitter, extracts the received counter value, and displays it on the Serial Monitor along with signal strength (RSSI) and signal quality (SNR).

Every time a packet is received, an LED turns ON and the data is also saved to an SD card (if present) for logging and later analysis. Together with the transmitter sketch, this forms a complete point-to-point LoRa test link, where one Arduino sends an increasing counter every second and the other Arduino receives, displays, and records it.

Key Points-

This command sets the unique ID (address) of this LoRa module to 2, so the transmitter can send data specifically to this receiver instead of broadcasting to everyone.
Also remember that not only the frequency and address, but all the LoRa radio parameters such as bandwidth, spreading factor, coding rate, and CRC settings must be exactly the same on both the transmitter and the receiver. If any of these parameters are different, the receiver will not be able to correctly decode or interpret the signal, even if everything else looks fine.

If you have any questions, doubts, or suggestions, feel free to let me know in the comments. You can also watch the full video for a more detailed explanation and complete walkthrough of the project.

Test Method-

Now let’s talk about my testing setup.

Many people message me saying that they are not getting good range from their LoRa modules. My main secret trick to achieve long range is actually my testing setup. I don’t cheat, and I don’t use any clever tricks. I just use the LoRa modules the way they are supposed to be used.

I place my transmitter LoRa module on my rooftop, and the transmitting antenna is about 3–4 meters above the rooftop. So, the total height of the transmitting antenna from ground level becomes around 20 to 25 meters. I have shown a photo of my transmitter antenna in the video.

Then I take the receiver LoRa module with me and slowly move away from the transmitter. Up to a certain distance, I always get a very good quality signal even from ground level. Depending on rural or semi-urban conditions, I usually get around 1 to 2.2 km of clear reception from the ground itself.

My transmitter is located in a semi-urban area, and the direction in which I go with the receiver is mostly open fields, jungle, and grassland up to the horizon. If you watch the full video, you’ll get a clear idea of this setup—and I think you’ll also enjoy the scenery of this place.

When the distance becomes more and line-of-sight from ground level is no longer possible, then my old and trusted F450 quadcopter comes in as the real hero.

When I stop receiving signals from the ground, I fly the receiver LoRa node using the drone. Depending on the distance and surrounding obstacles, the drone goes to a suitable height to clear obstructions, and then the receiver starts getting signals again. When it receives data, the green LED turns ON, which we can see from the ground.

Sometimes, due to distance, the HC-05 Bluetooth module cannot send live RSSI and SNR data to my mobile. That’s why, in this project, I also used an SD card module to log the data for later analysis of signal strength and SNR.

So this is the complete explanation of my testing setup.

If you have any questions about this setup, you can watch the video where I’ve explained everything in detail, or you can comment there directly—I’ll definitely reply.

Test Result-

3.1 km from the transmitter antenna: Stable signal received from ground level. RSSI: −116 dBm, SNR: −7 dB
5.8 km from the transmitter antenna: Stable signal received from ground level with no noticeable interference. Almost all data packets were received. RSSI: −116 dBm, SNR: −11 dB
7.3 km from the transmitter antenna: Unstable signal from ground level; signals were only available occasionally, probably due to a nearby village and vegetation. After flying the receiver using the drone to a few meters height, the signal became stable. RSSI: −110 dBm (better due to improved line-of-sight), SNR: −15 dB
10 km from the transmitter antenna: Stable signal received again from ground level. This location was a large open farmland with a very clear horizon, which likely helped. RSSI: −115 dBm, SNR: −12 dB
14 km from the transmitter antenna: This test point is not shown in the video. From ground level, we were getting a continuous and stable signal. The road was a few meters higher than the surrounding farmland, which probably helped. Unfortunately, no RSSI or SNR data was recorded at this point. We then decided to move further to 15 km.
15 km from the transmitter antenna: From ground level, the signal was very unstable and only available at certain spots and antenna positions. Although 14 km worked very well, performance dropped at 15 km, most likely due to dense vegetation and nearby forest (visible in the video and Google Maps). After flying the receiver using the drone, we again got a fairly stable signal. RSSI: −113 dBm, SNR: −14 dB.

I couldn’t continue this experiment beyond 15 km because it was already the second day of testing, and I had spent a significant amount of time and money on travel. I had already traveled more than 30–40 km, and the winter temperature in Bankura district was around 7°C. Due to this, I fell seriously ill with fever, so I had to stop the experiment at this point.

Conclusion-

According to the datasheet, this module is capable of receiving signals down to −148 dBm RSSI. Based on this specification and, more importantly, on my own real-world field test results, I am confident that this module can easily achieve communication distances beyond 20 km under good line-of-sight conditions. During my tests, I also observed that when the receiver is placed higher than ground level—for example on top of a building, on a rooftop, or even on a tree—the range can be extended even further due to better visibility and fewer obstructions.

This entire experiment has been carefully documented in my video with proper proof and real measurements. All experiments, tests, results, and opinions shown there are 100% real, honest, and based purely on actual field testing, not on assumptions or theoretical calculations, and are not influenced by any third party in any way.

About Me-

Hi! I’m Akash Bag (VU3HAX) — a B.Tech graduate in Electronics & Communication Engineering, currently pursuing M.Tech in Microwave Technologies, and a licensed ham radio operator from India.

I’m deeply passionate about DIY electronics, RF communication, RC planes and drones, microcontrollers, antennas, satellite reception, photography, music, and Bengali literature. I love building things, experimenting with them, sometimes breaking them 😄, and then understanding how and why they work (or don’t).

On AkashWave RF, I create practical, hands-on projects and tutorials based on Arduino, ESP, Raspberry Pi, RF modules, LoRa, HAM Radio, RTL-SDR, antennas, RC planes & drones, 3D printing, and satellite data reception. My focus is always on real learning and real experiments, not just flashy visuals.

My videos and projects may not always be cinematic, but I always try to make them honest, useful, and educational. If you love electronics, radio, and building things yourself, you’ll definitely feel at home here.

📡 Welcome to AkashWave RF!