If you’ve been following my journey with LoRaWAN, you’ll know I’m always on the lookout for ways to improve my network’s coverage and performance. That’s why I’m excited to share my experience with the ThinkNode G1 LoRaWAN gateway, a compact yet powerful device designed to help you build a robust LoRaWAN network. This gateway, sent to me by Elecrow, operates on the 868 MHz frequency band, which is perfect for my location in Europe.
In this article, I’ll walk you through the entire process of unboxing, setting up, and configuring this gateway. We’ll also test its range and see how well it performs in both the open field in front of my house as well as in the city area.
Tools and materials for IoT and LoRa projects
Below is a list of related tools and materials for making LoRa related projects. These are all affiliate links so if you purchase through them, I get a small commission at no extra cost for you. By doing so, you support me and my work so I can make future projects!
- ThinkNode G1 Gateway - https://s.click.aliexpress.com/e/_oEN7Vfe
- ESP32 Development Board - https://s.click.aliexpress.com/e/_oD7P4VW
- ESP32 SX1262 LoRa Development Board - https://s.click.aliexpress.com/e/_okQPBJm
- LILYGO® Meshtastic T-Beam ESP32 LoRa Development Board - https://s.click.aliexpress.com/e/_ol9s61m
- Ra-01SCH LoRa Module - https://s.click.aliexpress.com/e/_opif7xe
- SX1276 LoRa Module - https://s.click.aliexpress.com/e/_oDnfNOU
- Bench Power Supply - https://s.click.aliexpress.com/e/_opDsrOc
- Multimeter - https://s.click.aliexpress.com/e/_om9FUCy
- Soldering Station - https://s.click.aliexpress.com/e/_oF8YGWo
- Other Smart Devices - https://s.click.aliexpress.com/e/_oESYMlm
Unboxing and Initial Setup
When the ThinkNode G1 gateway arrived, the first thing I noticed was how well-packaged it was. Inside the box, you’ll find the gateway itself, a 12V power adapter, an antenna, and a user manual. The gateway has a sleek design with a black and gray plastic casing, and it feels sturdy yet lightweight.
Before powering it on, it’s crucial to connect the antenna first. This is a general rule for any LoRaWAN device—powering it on without an antenna can damage the internal components. The antenna port is neatly covered, and the included antenna screws on easily. Once the antenna is securely attached, I plugged in the power adapter and turned on the gateway. The power LED lit up immediately but since there was no network connection, I had to configure it first.
One feature that stood out to me was the 4G backup option. If you don’t have access to Wi-Fi or Ethernet, you can insert a nano SIM card to keep the gateway connected to the internet. This makes it ideal for remote locations where traditional internet connections might not be available.
Understanding the gateway’s Specifications
Before diving deeper into the setup, it’s important to understand what the ThinkNode G1 gateway is capable of. At its core, it’s powered by the SX1302 chip, which supports 8 channels and full LoRaWAN functionality. This means it can handle multiple devices simultaneously, making it a great choice for both small and large-scale projects. The gateway also comes with 128MB of RAM and 32MB of ROM, providing enough memory for smooth operation and firmware updates.
Since both the datasheet and the device manual claim that this gateway has a built-in network server, my original plan was to use it so that I create my own personal LoRaWAN network without it being connected to an external one like The Things Network (TTN). However, as I discovered later, this was in fact false and the gateway DOES NOT come with a built in server—something to keep in mind if you’re planning to run your own network. I've send recommendations to Elecrow to update their wording so that there are no confusions for any potential customers.
Other notable features include OpenVPN support for secure connections, frame buffering to store data during network outages, and listen-before-talk (LBT) functionality, which is essential for compliance with European frequency regulations. The gateway also has a 2.4GHz Wi-Fi interface and Bluetooth, though I didn’t find any immediate use for Bluetooth in the documentation. Overall, the ThinkNode G1 packs a lot of features into a compact device, making it a solid choice.
Configuring the gateway
Once the ThinkNode G1 gateway was powered on and the initial setup was complete, the next step was to configure it for the LoRaWAN network, by using TTN as the server. To start, I pressed the configuration button on the back of the gateway for 5 seconds. This put the device into configuration mode, indicated by a blue LED light. In this mode, the gateway creates its own Wi-Fi access point, which I connected to from my computer.
After connecting to the gateway’s Wi-Fi, I opened a browser and navigated to 192.168.1.1, the default IP address for the gateway’s web interface. The login screen appeared, and I entered the default credentials: username "root" and password "root". Once logged in, I was greeted with the gateway’s firmware interface, where I could adjust various settings.
The first thing I configured was the internet connection. Since I planned to use a wired connection, I selected Ethernet as the interface. Next, I set the frequency to 868 MHz, which is the standard for LoRaWAN in Europe. By default, teh gateway was already set to connect to TTN so I chose this option to test the gateway’s functionality. After saving the settings, the gateway was ready to forward data packets to the network.
Mounting the gateway in the Attic
With the ThinkNode G1 gateway configured and ready to go, the next step was to find the best location to maximize its coverage. Since I live on a hill with a clear view of the surrounding fields and parts of the city, I decided to mount the gateway in my attic. This location offers a high vantage point with minimal obstacles, ensuring the best possible signal range.
The attic is an ideal spot because it’s indoors, protecting the gateway from weather conditions, while still being high enough to reduce interference from buildings and other structures. The only obstacles are the wooden roof beams and ceramic tiles above, which shouldn’t significantly impact the signal. I placed the gateway near an existing power outlet to simplify the setup and avoid running long cables.
Before finalizing the placement, I made sure the antenna was securely connected and positioned vertically for optimal performance. Once everything was in place, I powered on the gateway and confirmed that it was operational. The LoRa indicator light showed a stable connection, and I was ready to test its range.
Mounting the gateway in the attic not only maximizes its coverage but also keeps it safe and accessible for future adjustments or maintenance.
Testing the Gateway’s Range
With the ThinkNode G1 gateway mounted in the attic, it was time to put its range to the test. To do this, I built a simple ESP32-based LoRaWAN device equipped with a Reyax RYLR993 module that I've already featured on my previous projects.
This device is programmed to send random data packets to the gateway when the BOOT button o the ESP32 was pressed, allowing me to confirm that the gateway’s is communicating successfully. As an indicator for a successful connection I used the on board LED on pin 2 to light it up when the device successfully joined the LoRaWAN network.
The full device code is available below.
#include <SoftwareSerial.h>
#include <CayenneLPP.h>
#define RX_lora 15
#define TX_lora 4
#define BUTTON_PIN 0
#define LED_PIN 2
EspSoftwareSerial::UART lora_serial;
bool network_joined = false;
CayenneLPP lpp(51); // Allocate a buffer size for CayenneLPP
void setup()
{
Serial.begin(115200);
lora_serial.begin(9600, SWSERIAL_8N1, RX_lora, TX_lora, false);
//wait a bit for serail to stabilize
delay(1000);
pinMode(LED_PIN, OUTPUT);
digitalWrite(LED_PIN, LOW);
pinMode(BUTTON_PIN, INPUT_PULLUP);
//try join LoRaWAN - device params are already set
sendLoraCommand("AT+JOIN=1");
delay(100);
checkForLoRaData();
}
void loop() {
if (Serial.available()){
String content = Serial.readString();
content.trim();
Serial.println("Writing to Lora Module");
sendLoraCommand(content);
}
checkForLoRaData();
if(network_joined) {
digitalWrite(LED_PIN, HIGH);
} else {
digitalWrite(LED_PIN, LOW);
}
if (digitalRead(BUTTON_PIN) == LOW) { // button is pressed
int randomNumber = random(0, 100); // Generate random number between 0 and 99
lpp.reset();
lpp.addAnalogInput(1, randomNumber);
sendLoraCayenne(lpp.getBuffer(), lpp.getSize());
delay(1000); //debounce
}
}
void checkForLoRaData() {
if (lora_serial.available()) {
String incomming = lora_serial.readString();
incomming.trim();
Serial.println("Received from Lora Module:");
Serial.println(incomming);
if(incomming.indexOf("+EVT:JOINED") >= 0) {
Serial.println("Joined LoRaWAN!");
network_joined = true;
} else if(incomming.indexOf("+EVT:JOIN FAILED") >= 0) {
Serial.println("Failed to join LoRaWAN :) Retry!");
sendLoraCommand("AT+JOIN=1");
network_joined = false;
}
}
}
void sendLoraCommand(String command) {
command = command + "\r\n";
char* buf = (char*) malloc(sizeof(char) * command.length() + 1);
Serial.println(command);
command.toCharArray(buf, command.length() + 1);
lora_serial.write(buf);
free(buf);
}
void sendLoraCayenne(uint8_t *data, uint8_t size) {
String command = "AT+SEND=1:1:";
for (unsigned char i = 0; i < size; i++)
{
if(data[i] < 0x10) {
command += '0';
}
command += String(data[i], HEX);
}
command += "\r\n";
Serial.println(command);
//only send data if joined to LoRaWAN network
if(network_joined) {
char* buf = (char*) malloc(sizeof(char) * command.length() + 1);
command.toCharArray(buf, command.length() + 1);
lora_serial.write(buf);
free(buf);
} else {
Serial.println("Not sent, not joined!");
sendLoraCommand("AT+JOIN=1");
}
}
I started by testing the setup indoors to ensure everything was working correctly. After powering on the ESP32 device, it successfully joined the LoRaWAN network, indicated by a blue LED turning on. Pressing the button sent data to the gateway, which I could see in real-time on The Things Network console. This confirmed that the gateway was receiving and forwarding data as expected.
Next, I took the ESP32 device to various locations around the city to test the gateway’s range. I started close to home, within line of sight, and gradually moved further away, including into more urban areas with buildings and other obstacles. At each location, I powered on the device, waited for it to join the network, and sent test data. The results were impressive—the gateway maintained a strong connection up to 8 kilometers in open areas, though performance dropped in dense urban environments where obstacles blocked the signal.
As expected, the gateway was providing coverage from where it was visible so this now opens possibilities for setting up projects that will use it.
Conclusion and next steps
One of the most exciting aspects of LoRaWAN is the potential for community involvement. I’ve decided to keep my gateway active and accessible on The Things Network, so anyone in the area can use it for their own LoRaWAN experiments. Whether you’re building environmental sensors, tracking devices, or just exploring IoT technology, this gateway is available to help. If you’re nearby and want to collaborate or test your own devices, feel free to reach out—I’d love to see what you create!
If you found this guide helpful or are inspired to start your own LoRaWAN project, I’d love to hear from you! Leave a comment below with your thoughts, questions, or ideas. Don’t forget to subscribe to my channel for more DIY electronics tutorials and LoRaWAN content.
Thanks for reading, and I’ll see you in the next project! 🚀
