DEV Community: Ganesh Kumar

How to Secure Nomad?

Ganesh Kumar — Sun, 19 Apr 2026 04:27:20 +0000

Hello, I'm Ganesh. I'm building git-lrc, an AI code reviewer that runs on every commit. It is free, unlimited, and source-available on Github. Star Us to help devs discover the project. Do give it a try and share your feedback for improving the product.

Nomad is a flexible workload orchestrator that enables an organization to easily deploy and manage any containerized or legacy application using a single, unified workflow.

Nomad can run a diverse workload of Docker, non-containerized, microservice, and batch applications.

With powerful features, it becomes very important to secure the Nomad cluster.

If anyone gets access to the cluster, it can lead to a big security risk.

In this article I will explain how to secure the Nomad cluster.

Enable ACL in Nomad

ACL is a feature in Nomad that allows you to control access to the cluster.

It is a way to implement the principle of least privilege, which means that users should only have access to the resources that they need to do their job.

To enable ACL in Nomad, you need to add the following lines to your Nomad server configuration file:

/etc/nomad.d/nomad.hcl

acl {
  enabled = true
}

Once it is enabled, you need to restart the Nomad server to apply the changes.

sudo systemctl restart nomad

Generate Security Token for Nomad

Once ACL is enabled, you need to generate a security token for Nomad.

You need to bootstrap the ACL system to generate the initial security token.

nomad acl bootstrap

It will return something like this

Accessor ID  = <ACCESSOR_ID>
Secret ID    = <SECRET_ID>
Name         = Bootstrap Token
Type         = management
Global       = true
Create Time  = <timestamp>
Expiry Time  = <none>
Create Index = <create_index>
Modify Index = <modify_index>
Policies     = n/a
Roles        = n/a

Copy and to a secure location. You will need this token to access the Nomad UI and API.

Once this is done if we try to access the Nomad UI or API without the token, it will return 403 Forbidden.

Which means ACL is enabled and working.

Create Policy for Users

As it is recommended not to use bootstrap token directly, we should create policies for users based on their roles.

Based on requirements you can create policies for users.

For example, let's create a policy for a user who can only read the jobs and node information.

Readonly access policy for a user.

namespace "default" {
  policy       = "read"
  capabilities = ["list-jobs", "read-job"]
}

agent {
  policy = "read"
}

operator {
  policy = "read"
}

quota {
  policy = "read"
}

node {
  policy = "read"
}

host_volume "*" {
  policy = "read"
}

This will make sure only read access for the users. This may be given to monitoring tools to monitor the cluster.

Create this file in ./nomad/policies/readonly.hcl

Once done create a token for this policy.

nomad acl policy apply -description "Readonly policy" readonly ./nomad/policies/readonly.hcl
Successfully wrote "readonly" ACL policy!

Create Keys for Selected Policy

nomad acl token create -name="Read Only Token" -policy="readonly"

This will return

Accessor ID  = <ACCESSOR_ID>
Secret ID    = <SECRET_ID>
Name         = Read Only Token
Type         = client
Global       = false
Create Time  = <timestamp>
Expiry Time  = <none>
Create Index = <create_index>
Modify Index = <modify_index>
Policies     = [readonly]

Roles
<none>

Now with this token we can access the Nomad UI and API with read only access.

Conclusion

Nomad is very powerful tool for orchestrating containers and other workloads.
But if we leave it unsecured it can be a security risk.
It is very important to secure the Nomad cluster.

So, I hope you understood how to secure the Nomad cluster.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

How to Configure Nginx as a Proxy Server?

Ganesh Kumar — Fri, 17 Apr 2026 08:33:33 +0000

In previous article we could able to server simple html page.

Now lets see how to use nginx as a proxy server.

Setting Up a Simple Proxy Server

One of the frequent uses of nginx is setting it up as a proxy server, which means a server that receives requests, passes them to the proxied servers, retrieves responses from them, and sends them to the clients.

We will configure a basic proxy server, which serves requests on behalf of another server running in port 8080.

Here is example of how to configure it.

# This is a comment in the Main Context
worker_processes 1; 

events { 
    # This is a simple directive inside the 'events' context
    worker_connections 1024; 
}

http { 
    # We are now inside the 'http' context

    server { 
        location / {
            proxy_pass http://localhost:8080; # Proxies traffic to the backend on 8080

        }
    }
}

This will be a simple server that listens on the port 8080.

Add Static Files For Existing Proxy Server

let's assume we have a static files in /var/www/html directory and we want to server another application running on port 8080.

so, we can configure both these in nginx it self.

# This is a comment in the Main Context
worker_processes 1; 

events { 
    # This is a simple directive inside the 'events' context
    worker_connections 1024; 
}

http { 
    # We are now inside the 'http' context

    server { 
        location / {
            proxy_pass http://localhost:8080; # Proxies traffic to the backend on 8080

        }

        location /static/ {
            root /var/www/html; # Serves static files from /var/www/html
        }
    }
}

This way we will be able to serve both static files and other server running in port 8080.

Conclusion

We could able to setup simple proxy server and serve both static files and other server running on different port.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

How to Expose Localhost to the Public Using Nginx and SSH Tunnels

Ganesh Kumar — Tue, 14 Apr 2026 12:56:05 +0000

As a developer, you’ve likely faced this hurdle: You are building a complex application on your local machine, and you need to show it to a client or test a webhook of your application.

You could deploy it to a staging server, but that's slow.
You could use Ngrok, but the free tier has limits and dynamic URLs.

Today, I’ll show you how to build your own "Unlimited" Reverse Proxy using Nginx, Autossh, and a small VPS.

The Architecture

The goal is to route traffic from a professional URL (like test1.yourdomain.com) directly to a port on your local machine (like localhost:3000).

We use three layers of technology to make this happen:

Nginx: Acts as the entry point and handles SSL (HTTPS).
SSH Reverse Tunnel: Creates a secure "pipe" from your VPS back to your laptop.
Autossh: Ensures that if your internet flickers, the "pipe" automatically reconnects.

Step 1: The Remote Server (Nginx)

On your server, you need an Nginx configuration that listens for HTTPS traffic and passes it to a local port.

server {
    listen 443 ssl http2;
    server_name test1.yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/your-domain/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/your-domain/privkey.pem;

    location / {
        # Proxy traffic to the SSH-forwarded port
        proxy_pass http://127.0.0.1:6540;

        # Keep the original user's info
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto https;
    }
}

Step 2: The Local Bridge

On your local machine, you need to open the tunnel.

Using a Makefile or a shell script makes this repeatable. The core command uses the -R flag, which stands for Remote Forward.

# -R [Remote Port]:[Local Destination]:[Local Port]
autossh -M 20000 -R 6540:localhost:3000 root@your-server -N

Why this is "Unlimited"

Unlike third-party services, this setup gives you:

Total Control: No timeout limits or bandwidth caps (other than your own ISP's speed).
Professionalism: You use your own domain and your own SSL certificates.
Security: Your local machine is not truly "exposed." Only the specific port you choose (8081) is bridged through the encrypted SSH tunnel.

Troubleshooting Common Gotchas

502 Bad Gateway: This usually means Nginx is working, but your SSH tunnel isn't running or is on the wrong port.
Port Already in Use: If you restart your tunnel quickly, the server might still think the old one is active. Use a cleanup script to kill -9 <PID> any process currently sitting on your remote port before starting a new one.
Firewalls: Ensure your VPS allows traffic on ports 80 and 443!

Conclusion

By combining the stability of Nginx with the flexibility of SSH tunneling, you've created a production-grade development environment.

You now have a permanent bridge between your local setup and the rest of the world.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

How Do Smart Devices Perform Multiple Tasks?

Ganesh Kumar — Sun, 12 Apr 2026 19:05:38 +0000

Ever wonder how your Alexa, robot vacuum cleaner, and smartwatch seamlessly perform multiple tasks without getting stuck in the middle? How exactly are these devices programmed to handle it all?

You came to the right place to understand how it happens under the hood.

In this article, we will understand how these tasks are performed and how they work.

As all these devices use a microcontroller. I will be explaining using the simple microcontroller ESP8266.

How will the task be performed?

Every smart device consists of a microcontroller. These microcontrollers are programmed to perform specific tasks.

These tasks are performed using a single loop function.

void loop() {
 // Perform Task
}

This loop function will run continuously.

In this loop, we can do multiple things.

Let's take the example of a weather monitoring device.
These operations are done using a single loop function. As there is nothing else to do.

Start Device
Start Loop
Read sensor data
Display data / Store data
Repeat the process

void loop() {
 // Read data from sensor
  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

 // Send data to cloud
  sendDataToCloud(temperature, humidity);
}

But this comes with a problem.

This loop will be running with a microsecond delay.
If we run this loop function, it will run continuously. Means there will be no delay between the operations.

How will a normal loop cause a problem?

Let's assume the above operation takes 1 ms (which is not true in real-world use, as it depends on which microcontroller you use).

The DHT11 sensor should have a 1-second delay between readings.

That means the above loop will run 1000 times in 1 second to just see if the sensor data has changed.

Can you see the problem?

1000 times operation means 1000 times power consumption.

1000 times the power consumption means the battery will drain fast, or the embedded system will heat up.

To avoid this, we can use a delay function.

void loop() {
 // Read data from sensor
  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

 // Send data to cloud
  sendDataToCloud(temperature, humidity);

 // Wait for 1 second
  delay(1000);
}

By adding a delay, we are making sure that the loop function is not running continuously.

This is a good implementation if we have only one task to perform.

But if we want to do multiple operations to be performed in specific intervals.

Adding Other Operations in a loop

Like this, if we want to read the DHT11 sensor every 1 second and read the MQ2 sensor every 5 seconds. We can't use the delay function.

It will be like this.

void loop() {
 // Read data from sensor
  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

 // Send data to cloud
  sendDataToCloud(temperature, humidity);
 // Read data from sensor
  float gas = analogRead(MQ2_PIN);

 // Send data to cloud
  sendDataToCloud(gas);

 // Wait for 5 seconds
  delay(5000);
}

This will cause a 5-second no-data reading from the DHT11 sensor.

Hence, there will be data loss for 5 seconds.

Here is where the task scheduler comes into the picture.

What is Task Scheduler?

A task scheduler is a lightweight system that allows a processor to juggle multiple activities seemingly at the same time, a concept known as multitasking.

A Task Scheduler solves this problem using a "to-do list" approach.

Instead of freezing, the program loops continuously at top speed.

Every time it loops, the scheduler checks the clock and looks at its list of tasks to see if any are due to run right now.

If a task's time is up, the scheduler runs it and then immediately goes back to checking the clock.

To understand the internal clock, imagine the microcontroller holding a stopwatch that starts counting milliseconds the moment it powers on.

In the Arduino framework, this stopwatch is read using a function called millis().

Instead of pausing the whole system to wait, the scheduler constantly checks this stopwatch against a simple formula for each task:

Current Time - Last Time Executed >= Interval

Here is a simple example of how the task scheduler works in ESP8266.

Ex:

unsigned long previousDHTTime = 0; // Remembers the last time DHT ran
unsigned long previousMQ2Time = 0; // Remembers the last time MQ2 ran

const long dhtInterval = 1000; // 1000 milliseconds = 1 second
const long mq2Interval = 5000; // 5000 milliseconds = 5 seconds

void setup() {
 // Initialization code goes here
}

void loop() {
 // 1. Read the internal stopwatch
  unsigned long currentMillis = millis(); 

 // 2. Check the DHT Task
  if (currentMillis - previousDHTTime >= dhtInterval) {
 previousDHTTime = currentMillis; // Reset this task's timer
    float temperature = dht.readTemperature();
    float humidity = dht.readHumidity();

 // Send data to cloud
    sendDataToCloud(temperature, humidity);

 }

 // 3. Check the MQ2 Task
  if (currentMillis - previousMQ2Time >= mq2Interval) {
 previousMQ2Time = currentMillis; // Reset this task's timer

    float gas = analogRead(MQ2_PIN);

 // Send data to cloud
    sendDataToCloud(gas);
 }
}

This way, we can perform multiple operations in specific intervals without blocking the loop function.

Core Logic of Task Scheduler

I want to perform two operations in ESP8266.

Blink the LED every 2.5 seconds 1 time.
Blink the LED every 5 seconds 2 times.

Let's see how to do this without using the built-in task scheduler.

Set up serial communication and the LED pin.
Start Loop.
Check if 2.5 seconds have passed since the last task activation.
If yes, perform the blink.
Check if 5 seconds have passed since the last task activation.
If yes, perform the blink

#include <Arduino.h>

unsigned long t25, t50;

/**
 * Performs a single blink on the built-in LED (Active Low).
 * @param message Debug message to output to Serial.
 */
void performBlink(const char *message) {
  Serial.println(message);
  digitalWrite(LED_BUILTIN, 0); // LED ON
  delay(80);
  digitalWrite(LED_BUILTIN, 1); // LED OFF
  delay(80);
}

void setup() {
  Serial.begin(115200);
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, 1); // Start with LED OFF
}

void loop() {
 // Task 1: Every 2.5s (triggers at 2.5s, 5.0s, 7.5s...)
  if (millis() - t25 >= 2500) {
 t25 = millis();
    performBlink("[2.5s] 💡");
 }

 // Task 2: Every 5.0s (triggers at 5.0s, 10.0s...)
 // At 5s, both tasks trigger, resulting in a double blink.
  if (millis() - t50 >= 5000) {
 t50 = millis();
    performBlink("[5.0s] 💡");
 }
}

Output:

[2.5s] 💡
[5.0s] 💡
[2.5s] 💡
[2.5s] 💡
[5.0s] 💡

See, as we defined, to use a 2.5 sec interval for the first task and a 5 sec interval for the second task.

This also means the 2nd time, a 2.5 sec blink will happen after 5 sec from the 1st blink.

This will create a 2-second blink in 5 sec.

Using Task Scheduler

We are going to use the task scheduler library to perform multiple operations in specific intervals.

Let's see how to do this using the task scheduler library.

Include the task scheduler library.
Create a scheduler object.
Define tasks.
Add tasks to the scheduler.
Enable tasks.
Run the scheduler.

#include <Arduino.h>
#include <TaskScheduler.h>

Scheduler runner;

/**
 * Performs a single blink pulse.
 * Note: NodeMCU V2 built-in LED is active LOW.
 */
void pulse() {
  digitalWrite(LED_BUILTIN, 0); // ON
  delay(80);
  digitalWrite(LED_BUILTIN, 1); // OFF
  delay(80);
}

void Callback(const char *msg) {
  Serial.println(msg);
  pulse();
}

// Task Definitions
Task t25(2500, TASK_FOREVER, []() { Callback("[2.5s] 💡"); });
Task t50(5000, TASK_FOREVER, []() { Callback("[5.0s] 💡"); });

void setup() {
  Serial.begin(115200);
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, 1); // Start OFF

  runner.init();

 // Add tasks to the scheduler
  runner.addTask(t25);
  runner.addTask(t50);

 // Enable tasks
  t25.enable();
  t50.enable();
}

void loop() { runner.execute(); }

In this way, we can perform multiple operations in specific intervals without blocking the loop function.

Output:

[2.5s] 💡
[5.0s] 💡
[2.5s] 💡
[5.0s] 💡
[2.5s] 💡
[2.5s] 💡

You can also see that the 5.0s blink is happening first, and sometimes the 2.5s blink is happening first.

This is because of the task scheduler library. It has its own algorithm to perform the tasks.

How real world devices use task scheduler

In real-world devices, task scheduling depends on the complexity of the system.

For simple devices (like basic IoT systems using ESP8266), developers use the same approach we discussed earlier — non-blocking scheduling using millis() or lightweight task schedulers.

For more advanced devices, a Real-Time Operating System (RTOS) such as FreeRTOS is commonly used.

An RTOS allows:

Running multiple tasks with priorities
Executing time-critical tasks without delay
Managing communication between tasks

For example, a smart device can:

Read sensors periodically
Handle WiFi communication
Update display
Respond to user input

All these tasks run efficiently using a scheduler without blocking each other.

In short, real-world systems use more advanced schedulers, but the core idea remains the same as the simple loop-based scheduler explained earlier.

Conclusion

We understood how smart devices perform multiple tasks using the task scheduler and how to use it to perform multiple operations in specific intervals without blocking the loop function.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

How does SSH work and how can it be set up?

Ganesh Kumar — Fri, 10 Apr 2026 10:51:40 +0000

Secure Shell (SSH) is a cryptographic network protocol that allows you to operate network services securely over an unsecured network.

It is most commonly used for logging into a remote terminal and executing commands.

How SSH Works

SSH uses a client-server model and relies on a suite of encryption technologies to ensure that data remains confidential and untampered.

1. The Handshake

When we connect to a server, the two machines exchange supported encryption protocols and settle on a mutually compatible version.

They also establish a session key using a process like the Diffie-Hellman algorithm, which allows them to create a shared secret without actually sending the key across the network.

Here is the video explaining this process:
Link

2. Authentication

Once the encrypted channel is established, the server needs to verify who you are. This usually happens in one of two ways:

Password Authentication: You send your password through the encrypted tunnel.
Key-based Authentication: The most secure method, using a Public Key (stored on the server) and a Private Key (stored on your machine).

3. Encryption Layers

SSH utilizes three different types of encryption:

Symmetrical Encryption: Uses one key for both encryption and decryption of the entire session.
Asymmetrical Encryption: Uses a public/private key pair (used primarily during the handshake and for authentication).
Hashing: Uses algorithms (like HMAC) to ensure data integrity, proving that the packets haven't been altered during transit.

For let's setup simple RSA key pair for ubuntu server.

How to Setup SSH

Since we are using ubuntu server, we need to install the SSH server on the server.

Step 1: Install the SSH Server

Assuming you are in cloud console want to setup ssh on ubuntu.

On the server, run:

sudo apt update
sudo apt install openssh-server

To check if it’s running:

sudo systemctl status ssh

Step 2: Generate SSH Keys (Recommended)

On your local machine, generate a key pair. This is much safer than using a password.

ssh-keygen -m PEM -t rsa -b 4096 -f ~/.ssh/private_key

Press Enter to save it in the default location.

You can add a passphrase for extra security.

gk@jarvis:~$ ssh-keygen -m PEM -t rsa -b 4096 -f ~/.ssh/private_key
Generating public/private rsa key pair.
Enter passphrase (empty for no passphrase): 
Enter same passphrase again: 
Your identification has been saved in /home/gk/.ssh/private_key
Your public key has been saved in /home/gk/.ssh/private_key.pub
The key fingerprint is:
SHA256:i3qqpQpyRkjDAdnbe++rN+ZCzak/4Ryzsn5vGJYEsVg gk@jarvis
The key's randomart image is:
+---[RSA 4096]----+
|o+    E.         |
|o o  o..         |
| + o. ..         |
|..o .   .        |
|. .  . +So       |
| .  . o.@.       |
|o o .o.*.B       |
|oo o .= % .      |
|..o.o++%=*.      |
+----[SHA256]-----+

In the above output, we have generated a private key and public key.

we can copy public key and save it in server

Step 3: Copy the Key to the Server

Copy public key from local machine.

cat ~/.ssh/private_key.pub

Once you are inside server either in temperary console or using password.

Change directory to .ssh

Add public key to authorized_keys file.

This way server will trust your public key and you can login without a password.

Step 4: Connect

Now you can log in without a password:

ssh username@remote_host_ip

Conclusion

We understood how ssh works and how to setup ssh on server.

I hope this article helps you to understand ssh and how to setup ssh on server.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

How to Configure and Control Nginx?

Ganesh Kumar — Wed, 08 Apr 2026 10:59:42 +0000

In previous article I explinaed how nginx works and what is the architecture of nginx.

Now let's configure it and controls nginx.

Understanding Nginx Controls

Reload

nginx -s reload

This signal is used to reload the configuration files of nginx.
It will not stop the nginx processes.
It will just reload the configuration files and start the new worker processes.
If old worker process serving few clients it will be served by old worker process.

Either master will stop old worker process or it will wait for the old worker process to finish serving the current requests.

This way if anything has issues nginx will not apply new configuration files.

Quit

nginx -s quit

This signal is used to quit the nginx processes.

It will stop the nginx processes and wait for the worker processes to finish serving the current requests.

Stop

nginx -s stop

This signal is used to stop the nginx processes.

It will stop the nginx processes and wait for the worker processes to finish serving the current requests.

To stop nginx with PID. We can use kill command.

kill -QUIT <master_pid>

We can also find all PID

ps -ax | grep nginx

Configure Nginx

nginx consists of modules which are controlled by directives specified in the configuration file.

These Directives are divided into simple directives and block directives.

Similar to C language, simple directive consists of the name and parameters separated by spaces and ends with a semicolon (;).

A block directive has the same structure as a simple directive, but instead of the semicolon it ends with a set of additional instructions surrounded by braces ({ and }).

If a block directive can have other directives inside braces, it is called a context (examples: events, http, server, and location).

Directives placed in the configuration file outside of any contexts are considered to be in the main context. The events and http directives reside in the main context, server in http, and location in server.

The rest of a line after the # sign is considered a comment.

Here is the simple example of nginx configuration file:

Main context: worker_processes 1;

events context: worker_connections 1024;

http context: we define server context here.

server context: In here we define this to listen port 80 which is http port.

location context: In here we define the root directory of the website.

So, any request coming to port 80 will be served by the worker process with the root directory of /var/www/html.

# This is a comment in the Main Context
worker_processes 1; 

events { 
    # This is a simple directive inside the 'events' context
    worker_connections 1024; 
}

http { 
    # We are now inside the 'http' context

    server { 
        # The 'server' context is nested inside 'http'
        listen 80; 

        location / { 
            # The 'location' context is nested inside 'server'
            root /var/www/html; 
        }
    }
}

Conclusion

We understood how to control nginx and how to configure nginx.

So, this makes solid foundation for us to understand how work with nginx.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

How Nginx Architecture is Designed and How They Work

Ganesh Kumar — Mon, 06 Apr 2026 12:59:24 +0000

In the previous article, We have seen how to setup nginx on ubuntu and enable the site. It was more into basic where anyone one who wants to configure domain or any other thing can follow it.

Now in this article we will explore a how nginx works.

How Nginx Architecture and How they Works?

Before we go into how nginx works, we need to understand the architecture of nginx.

Nginx has two main components:

Master Process
Worker Process

Master process is to read, evaluate configuration files and maintain worker process.

Worker Process will do all the processing of client requests.

Nginx works on principle of event-based and OS-dependent mechanisms to efficiently distribute requests among worker processes.

The number of worker process can be configured in the nginx.conf file and this can also be automatically set based on the number of CPU cores available on the system.

For more information on how to configure the number of worker process, please refer to the official documentation Worker Processes.

By default, the configuration file is named nginx.conf and placed in the directory /usr/local/nginx/conf, /etc/nginx, or /usr/local/etc/nginx.

How to Start, Stop and Reload Nginx?

To Control any operation of nginx, we need to use the executable file.

This will be having this syntax:

nginx -s signal

Where signal may be one of the following:

stop — fast shutdown
quit — graceful shutdown
reload — reloading the configuration file
reopen — reopening the log files

For example, to stop nginx processes with waiting for the worker processes to finish serving current requests, the following command can be executed:

nginx -s quit

Conclusion

As of now we understand how Nginx architecture works and how to control Nginx.

In the next article, we will go in-depth on how to use these signals to control Nginx.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

How to Connect a DHT11 to a NodeMCU v2 board?

Ganesh Kumar — Sat, 04 Apr 2026 16:59:31 +0000

In this article, we will see how to work with DHT11 sensor with NodeMCU v2 using PlatformIO.

Hardware Check

We should always check datasheets before working with any hardware.

So, by checking the datasheet of DHT11 and NodeMCU v2, we can determine how connection should be done and how to create firmware for it.

You can check datasheets here:

Power Compatibility

As per the datasheet of DHT11, it can operate on a supply range of 3V to 5.5V DC.
Since the NodeMCU v2 runs on 3.3V.

You can power the sensor directly from the NodeMCU's 3V3 pin. This keeps your build simple and safe without needing extra voltage regulators.

Also they recommend to use a pull-up resistor of 4.7K to 10K between VDD and DATA pins.To make sure data is read properly.

Hardware Identification

Check which version of the DHT11 you have. This changes how many pins you’ll be dealing with.

Feature	Bare DHT11 Sensor	DHT11 Module
Appearance	Blue plastic square with 4 metal pins.	Sensor soldered onto a small PCB.
Pin Count	4 Pins.	3 Pins.
Resistor	Required. You must add your own 4.7K to 10K resistor.	Built-in. Usually pre-soldered on the board.

Step-by-Step Wiring Guide

For the 4-Pin Bare Sensor

If you are using the bare sensor, follow this pinout based on the official datasheet:

Pin 1 (VDD): Connect to the 3V3 pin on the NodeMCU.
Pin 2 (DATA): Connect to a digital pin like D1 or D2.
- Crucial Step: Place a 4.7K to 10K pull-up resistor between Pin 1 (VDD) and Pin 2 (DATA). This prevents the signal from "floating" and ensures stable data readings.
Pin 3 (NULL): Leave this disconnected. It serves no electrical purpose.
Pin 4 (GND): Connect to any GND pin on the NodeMCU.

For the 3-Pin Module

If you have the module, life is even easier. The board is usually labeled:

VCC (+): Connect to 3V3.
DATA (out): Connect to D1 or D2.
GND (-): Connect to GND.

Why the Pull-up Resistor Matters?

Without a pull-up resistor, the DATA line doesn't have a clear "High" or "Low" state when the sensor isn't talking, which leads to erratic readings or "Sensor not found" errors.

If you're using the bare sensor, don't skip the 4.7K to 10K resistor (though anything from 4.7K to 10K usually works in a pinch!).

Coding Your DHT11 with PlatformIO

Now that the hardware is ready.

Since we are using PlatformIO, we’ll need to configure our project environment and use the industry-standard Adafruit library.

1. Configure `platformio.ini`

First, we need to tell PlatformIO which board we are using and which library to download. Open your platformio.ini file and ensure it looks like this:

[env:nodemcuv2]
platform = espressif8266
board = nodemcuv2
framework = arduino
monitor_speed = 115200
lib_deps = 
    adafruit/DHT sensor library @ ^1.4.6
    adafruit/Adafruit Unified Sensor @ ^1.1.14

Note: The Adafruit Unified Sensor library is a hidden dependency that the DHT library needs to function correctly.

2. The Main Code (`src/main.cpp`)

In your project’s src folder, open main.cpp. We’ll use a modified version of your snippet specifically tuned for the DHT11.

#include <Arduino.h>
#include "DHT.h"

// Define the NodeMCU pin connected to the DHT11 data pin
// Using D2 (GPIO 4) as per our wiring guide
#define DHTPIN D2     

// Since we are using the DHT11, we specify it here
#define DHTTYPE DHT11   

// Initialize the DHT sensor
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  // Start serial communication at the speed defined in platformio.ini
  Serial.begin(115200);
  Serial.println(F("DHT11 Sensor Initializing..."));

  // Start the sensor
  dht.begin();
}

void loop() {
  // Wait 2 seconds between measurements. 
  // DHT11 is slower than modern sensors; don't rush it!
  delay(2000);

  // Reading temperature or humidity takes about 250 milliseconds!
  float h = dht.readHumidity();
  float t = dht.readTemperature(); // Celsius
  float f = dht.readTemperature(true); // Fahrenheit

  // Check if any reads failed
  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println(F("Failed to read from DHT sensor! Check your wiring."));
    return;
  }

  // Compute heat index (how it actually feels)
  float hic = dht.computeHeatIndex(t, h, false);

  // Print results to the Serial Monitor
  Serial.print(F("Humidity: "));
  Serial.print(h);
  Serial.print(F("%  |  Temp: "));
  Serial.print(t);
  Serial.print(F("°C  |  Heat Index: "));
  Serial.print(hic);
  Serial.println(F("°C"));
}

DHT11 Sensor Initializing...
Humidity: 45.00 %  |  Temp: 25.00°C  |  Heat Index: 25.00°C
Humidity: 46.00 %  |  Temp: 25.12°C  |  Heat Index: 25.12°C
Humidity: 45.00 %  |  Temp: 25.25°C  |  Heat Index: 25.25°C

Key Adjustments for the DHT11

DHTTYPE: Ensure this is set to DHT11. While the code for a DHT22 is almost identical, the timing and data conversion logic inside the library are different for these two models.
Sampling Rate: The DHT11 has a sampling rate of about 1Hz (one reading per second). Using a delay(2000) (2 seconds) is a "safe bet" to ensure you don't get stale data or errors.
Accuracy Note: Don't be surprised if the readings are slightly different from your home thermostat. The DHT11 is an entry-level sensor with an accuracy of ±2°C for temperature and ±5% for humidity.

Conclusion

We could able to connect DHT11 sensor with NodeMCU v2 using PlatformIO and read temperature and humidity values.

In next article we will learn different sensor.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

Why is Nginx configuration organized as sites-available and sites-enabled?

Ganesh Kumar — Thu, 02 Apr 2026 19:30:03 +0000

In this article, We will exploring how to do nginx configuration directory structure. Why it is organized in this way?

How are ngix config files organized?

Majorly nginx config files are organized in the following way:

Main config file: /etc/nginx/nginx.conf This deal with setting up global configuration for nginx.
Sites available directory: /etc/nginx/sites-available This deal with setting up sites configuration for nginx. Where we can write multiple site configuration files.
Sites enabled directory: /etc/nginx/sites-enabled This deal with enabling sites configuration for nginx. Where we can enable sites configuration.
Logs directory: /var/log/nginx This deal with logs configuration for nginx. Where we can see logs of nginx.
Cache directory: /var/cache/nginx This deal with cache configuration for nginx. Where we can see cache of nginx.

How to write site configuration file?

A site configuration file is a file that is used to configure a site for nginx.

Which you can further read in official documentation https://nginx.org/en/docs/.

These configuration should be written in this directory.

/etc/nginx/sites-available

Once you write the configuration file. This will not enable the site.

How to enable the site?

To enable the site, you need to create a symbolic link from the sites-available directory to the sites-enabled directory.

For example, if you have a site configuration file named example.com in the sites-available directory, you can enable it by running the following command:

we should always test the configuration file before enabling it.

sudo nginx -t

sudo ln -s /etc/nginx/sites-available/example.com /etc/nginx/sites-enabled/example.com

This will create a symbolic link from the sites-available directory to the sites-enabled directory.

The core reason for using symbolic link is that it will allow us to enable and disable the site without removing the configuration file.

if we directly put the configuration file in sites-enabled directory, then we need to remove the configuration file to disable the site.

That means if I want to update small change.
If the configration was copy to sites-enabled directory, then on nginx server restart, the changes will not be reflected.

so, to make it easier we use symbolic link.

Now once the site is enabled, we need to restart the nginx server to apply the changes.

sudo systemctl restart nginx

Finaly we can access the site in browser.

How to disable the site?

To disable the site, you need to remove the symbolic link from the sites-enabled directory.

sudo rm /etc/nginx/sites-enabled/example.com

By this process it will not delete the configuration file. We can enable and disable the site without removing the configuration file.

Conclusion

By this we understood how to enable and disable the site in nginx.

How configuration file is organized in nginx.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

How to use Task Scheduler in ESP8266?

Ganesh Kumar — Wed, 01 Apr 2026 12:06:54 +0000

In this article, We will be exploring inbult task function in ESP8266.

Core Logic of Task Scheduler

I want to perform two operations in ESP8266.

Blink LED every 2.5 seconds 1 time.
Blink LED every 5 seconds 2 times.

Let's see how to do this without using inbuilt task scheduler.

Setup Serial communication and LED pin.
Start Loop.
Check if 2.5 seconds have passed since the last task activation.
If yes, perform the blink.
Check if 5 seconds have passed since the last task activation.
If yes, perform the blink

#include <Arduino.h>

unsigned long t25, t50;

/**
 * Performs a single blink on the built-in LED (Active Low).
 * @param message Debug message to output to Serial.
 */
void performBlink(const char *message) {
  Serial.println(message);
  digitalWrite(LED_BUILTIN, 0); // LED ON
  delay(80);
  digitalWrite(LED_BUILTIN, 1); // LED OFF
  delay(80);
}

void setup() {
  Serial.begin(115200);
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, 1); // Start with LED OFF
}

void loop() {
  // Task 1: Every 2.5s (triggers at 2.5s, 5.0s, 7.5s...)
  if (millis() - t25 >= 2500) {
    t25 = millis();
    performBlink("[2.5s] 💡");
  }

  // Task 2: Every 5.0s (triggers at 5.0s, 10.0s...)
  // At 5s, both tasks trigger, resulting in a double blink.
  if (millis() - t50 >= 5000) {
    t50 = millis();
    performBlink("[5.0s] 💡");
  }
}

Output:

[2.5s] 💡
[5.0s] 💡
[2.5s] 💡
[2.5s] 💡
[5.0s] 💡

See as we defined to use 2.5 sec interval for first task and 5 sec interval for second task.

This also mean 2nd time 2.5 sec blink will happen after 5 sec from 1st blink.

This will create 2 times blink in 5 sec.

Using Task Scheduler

We are going to use task scheduler library to perform multiple operations in specific intervals.

Let's see how to do this using task scheduler library.

Include task scheduler library.
Create a scheduler object.
Define tasks.
Add tasks to the scheduler.
Enable tasks.
Run the scheduler.

#include <Arduino.h>
#include <TaskScheduler.h>

Scheduler runner;

/**
 * Performs a single blink pulse.
 * Note: NodeMCU V2 built-in LED is active LOW.
 */
void pulse() {
  digitalWrite(LED_BUILTIN, 0); // ON
  delay(80);
  digitalWrite(LED_BUILTIN, 1); // OFF
  delay(80);
}

void Callback(const char *msg) {
  Serial.println(msg);
  pulse();
}

// Task Definitions
Task t25(2500, TASK_FOREVER, []() { Callback("[2.5s] 💡"); });
Task t50(5000, TASK_FOREVER, []() { Callback("[5.0s] 💡"); });

void setup() {
  Serial.begin(115200);
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, 1); // Start OFF

  runner.init();

  // Add tasks to the scheduler
  runner.addTask(t25);
  runner.addTask(t50);

  // Enable tasks
  t25.enable();
  t50.enable();
}

void loop() { runner.execute(); }

By this way we can perform multiple operations in specific intervals without blocking the loop function.

Output:

[5.0s] 💡
[2.5s] 💡
[5.0s] 💡
[2.5s] 💡
[2.5s] 💡

You can also see 5.0s blink is happening first and sometimes 2.5s blink is happening first.

This is because of the task scheduler.

Conclusion

By this we understood how task scheduler works in ESP8266.

And we actualy used task scheduler to perform multiple operations in specific intervals without blocking the loop function.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

How to perform multiple operations in the ESP8266?

Ganesh Kumar — Mon, 30 Mar 2026 09:23:53 +0000

In this article, We will be exploring how to perform multiple operations in ESP8266.

As we are using ESP8266, we will be using Arduino framework.
Let see how operations are performed in ESP8266 or any other embedded system.

How Operations are performed in ESP8266?

Before going to understand how to perform multiple operations in ESP8266. Let's understand what is how regular programming works in embedded systems.

Any activity in embedded system is done using loop function.

void loop() {
  // Do something
}

This loop function will run continuously.

In this loop we can do multiple things.

For example we can read dht11 sensor data

void loop() {
  // Read data from sensor
  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

  // Send data to cloud
  sendDataToCloud(temperature, humidity);
}

But this comes with a problem.

If we run this loop function, it will run continuously. Means there will be no delay between the operations.

How Normal Loop will cause problem?

Let's assume above operation takes 1 ms (which is not true in real world).
And DHT11 sensor should have 1 second delay between readings.

That means above loop will run 1000 times in 1 second to just see if the sensor data is changed.

Can you see the problem?

1000 times operation means 1000 times power consumption.

1000 times power consumption means battery will drain fast or embedded system will heat up.

To Avoid this we can use delay function.

void loop() {
  // Read data from sensor
  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

  // Send data to cloud
  sendDataToCloud(temperature, humidity);

  // Wait for 1 second
  delay(1000);
}

By adding delay we are making sure that the loop function is not running continuously.

But this also has a problem.

If we add delay of 1 second, it means the loop function will run only once in 1 second.

So if we want to do multiple operations to be performed in specific intervals. It will be blocked.

Adding Other Operation in loop

Like this if we want to read dht11 sensor every 1 second and read mq2 sensor every 5 seconds. We can't use delay function.

It will be like this

void loop() {
  // Read data from sensor
  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

  // Send data to cloud
  sendDataToCloud(temperature, humidity);
  // Read data from sensor
  float gas = analogRead(MQ2_PIN);

  // Send data to cloud
  sendDataToCloud(gas);

  // Wait for 5 seconds
  delay(5000);
}

This will cause 5 sec no data reading from dht11 sensor.

Here where task scheduler comes into picture.

What is Task Scheduler?

A task scheduler is a lightweight system that allows a processor to juggle multiple activities seemingly at the same time, a concept known as multitasking.

A Task Scheduler solves this problem using a "to-do list" approach.

Instead of freezing, the program loops continuously at top speed.

Every time it loops, the scheduler checks the clock and looks at its list of tasks to see if any are due to run right now.

If a task's time is up, the scheduler runs it, and then immediately goes back to checking the clock.

To understand the internal clock, imagine the microcontroller holding a stopwatch that starts counting milliseconds the moment it powers on.

In Arduino framework, this stopwatch is read using a function called millis().

Instead of pausing the whole system to wait, the scheduler constantly checks this stopwatch against a simple formula for each task:

Current Time - Last Time Executed >= Interval

Here is simple example of how task scheduler works in ESP8266.

Ex:

unsigned long previousDHTTime = 0;  // Remembers the last time DHT ran
unsigned long previousMQ2Time = 0;  // Remembers the last time MQ2 ran

const long dhtInterval = 1000;      // 1000 milliseconds = 1 second
const long mq2Interval = 5000;      // 5000 milliseconds = 5 seconds

void setup() {
  // Initialization code goes here
}

void loop() {
  // 1. Read the internal stopwatch
  unsigned long currentMillis = millis(); 

  // 2. Check the DHT Task ⏱️
  if (currentMillis - previousDHTTime >= dhtInterval) {
    previousDHTTime = currentMillis;  // Reset this task's timer
    float temperature = dht.readTemperature();
    float humidity = dht.readHumidity();

    // Send data to cloud
    sendDataToCloud(temperature, humidity);

  }

  // 3. Check the MQ2 Task ⏱️
  if (currentMillis - previousMQ2Time >= mq2Interval) {
    previousMQ2Time = currentMillis;  // Reset this task's timer

    float gas = analogRead(MQ2_PIN);

    // Send data to cloud
    sendDataToCloud(gas);
  }
}

This way we can perform multiple operations in specific intervals without blocking the loop function.

Conclusion

In this article we have seen how to perform multiple operations in specific intervals without blocking the loop function in ESP8266.

In next article we will use inbuilt task scheduler and itegrate with painlessmesh.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

How to Send Data from PainlessMesh to the Cloud Using MQTT in an ESP8266?

Ganesh Kumar — Sat, 28 Mar 2026 20:46:51 +0000

In this article, I will be demonstrating how to use PainlessMesh and MQTT with a NodeMCUv2 (ESP8266) board.

What Problem we are solving?

We will be reciving data from multiple nodes and send it to cloud using MQTT.

Publish the data from received at gateway to cloud using MQTT
Scallable MQTT topics publishing

How it works?

Receive data from multiple nodes

These data will be in compressed in these format.

void onMeshReceive(const uint32_t &from, const String &msg) {
  Serial.printf("[mesh] From %u: %s\n", from, msg.c_str());

  JsonDocument doc;
  if (deserializeJson(doc, msg) != DeserializationError::Ok) {
    Serial.println("[mesh] JSON parse failed");
    return;
  }

  const char *msgType = doc["type"] | "data";
  String topic = buildTopic(from, msgType);

  if (mqttClient.connected()) {
    mqttClient.publish(topic.c_str(), msg.c_str());
    Serial.printf("[mqtt] Published → %s\n", topic.c_str());
  } else {
    Serial.println("[mqtt] Not connected — message dropped");
  }
}

Publish the data from received at gateway to cloud using MQTT

Setup wifi credentials.

#define STATION_SSID "your_ssid"
#define STATION_PASSWORD "your_password"

Connect to wifi using painlessmesh.

As painlessmesh is heavy library it will consume lot of power and data.

So we will use mesh.stationManual() to connect to wifi.

 mesh.stationManual(STATION_SSID,
                     STATION_PASSWORD); // ← key: mesh owns the STA
  mesh.setHostname("ais-gateway")

Scallable MQTT topics publishing We will use MQTT to send data from gateway to cloud.

We will use these credentials for MQTT.

#define MQTT_HOST "your_mqtt_host"
#define MQTT_PORT_TLS 8883
#define MQTT_USER "your_mqtt_user"
#define MQTT_PASS "your_mqtt_password"

We will use these topics for MQTT.

Each topic will have different meaning.

For example we will use these topics for MQTT.

For sending an industrial sensor data we will use these topics.

#define T_VERSION "v1"
#define T_TENANT "electrotech"
#define T_INDUSTRY "pcba"
#define T_SITE "plant1"
#define T_GATEWAY "gw_01"

Finally followed with config message.

{
  "type": "config",
  "schema": {
    "temp": {"type":"float","scale":10,"offset":0,"min":0,"max":51.1},
    "hum": {"type":"float","scale":10,"offset":-20,"min":20,"max":122.3},
    "gas": {"type":"float","scale":0.1,"offset":0,"min":0,"max":1023}
  }
}

/**
 * gateway.cpp — PainlessMesh Root + MQTT Bridge (HiveMQ TLS)
 *
 * Follows the official painlessMesh MQTT bridge pattern:
 *   - mesh.stationManual() hands WiFi STA management to the mesh library
 *     so it never disconnects from the router to scan for mesh peers.
 *   - MQTT connect is triggered by IP change detection in loop().
 *   - mesh.setRoot(true) called BEFORE init().
 *
 * Data flow: sensor node → mesh → gateway → HiveMQ MQTT → backend
 * Topic format: v1/{tenant}/{industry}/{site}/{gateway}/{node}/{type}
 */

#include <Arduino.h>
#include <ArduinoJson.h>
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <WiFiClientSecure.h>
#include <painlessMesh.h>

// ─── WiFi credentials ────────────────────────────────────────────────────────
#define STATION_SSID "your_ssid"
#define STATION_PASSWORD "your_password"

// ─── Mesh credentials ────────────────────────────────────────────────────────
#define MESH_PREFIX "your_mesh_prefix"
#define MESH_PASSWORD "your_mesh_password"
#define MESH_PORT 5555

// ─── MQTT credentials (from backend .env) ────────────────────────────────────
#define MQTT_HOST "your_mqtt_host"
#define MQTT_PORT_TLS 8883
#define MQTT_USER "your_mqtt_user"
#define MQTT_PASS "your_mqtt_password"

// ─── Topic routing constants ─────────────────────────────────────────────────
#define T_VERSION "v1"
#define T_TENANT "electrotech"
#define T_INDUSTRY "pcba"
#define T_SITE "plant1"
#define T_GATEWAY "gw_01"

// ─── Globals ─────────────────────────────────────────────────────────────────
painlessMesh mesh;
BearSSL::WiFiClientSecure wifiClient;
PubSubClient mqttClient(wifiClient);
IPAddress myIP(0, 0, 0, 0);
unsigned long lastMqttAttempt = 0;

// ─── Helpers ─────────────────────────────────────────────────────────────────

String buildTopic(uint32_t nodeId, const char *msgType) {
  return String(T_VERSION) + "/" + T_TENANT + "/" + T_INDUSTRY + "/" + T_SITE +
         "/" + T_GATEWAY + "/" + String(nodeId) + "/" + msgType;
}

IPAddress getStationIP() { return IPAddress(mesh.getStationIP()); }

// ─── MQTT callback (placeholder for future /cmd downlink) ────────────────────
void mqttCallback(char *topic, byte *payload, unsigned int len) {
  Serial.printf("[mqtt] Received on %s: %.*s\n", topic, (int)len,
                (char *)payload);
  // Phase 2: parse /cmd and forward to specific mesh node via mesh.sendSingle()
}

// ─── Mesh callback: forward every message to the correct MQTT topic
// ───────────
void onMeshReceive(const uint32_t &from, const String &msg) {
  Serial.printf("[mesh] From %u: %s\n", from, msg.c_str());

  JsonDocument doc;
  if (deserializeJson(doc, msg) != DeserializationError::Ok) {
    Serial.println("[mesh] JSON parse failed");
    return;
  }

  const char *msgType = doc["type"] | "data";
  String topic = buildTopic(from, msgType);

  if (mqttClient.connected()) {
    mqttClient.publish(topic.c_str(), msg.c_str());
    Serial.printf("[mqtt] Published → %s\n", topic.c_str());
  } else {
    Serial.println("[mqtt] Not connected — message dropped");
  }
}

// ─── Setup ───────────────────────────────────────────────────────────────────
void setup() {
  Serial.begin(115200);
  delay(100);

  // 1. Mesh — setRoot() and stationManual() BEFORE init()
  //    stationManual() hands STA management to the mesh library:
  //    it will NOT disconnect from the router to scan for mesh peers.
  mesh.setDebugMsgTypes(ERROR | CONNECTION);
  mesh.setRoot(true);
  mesh.setContainsRoot(true);
  mesh.init(MESH_PREFIX, MESH_PASSWORD, MESH_PORT, WIFI_AP_STA); // auto channel
  mesh.onReceive(&onMeshReceive);
  mesh.onNewConnection(
      [](size_t id) { Serial.printf("[mesh] +Node %u\n", (uint32_t)id); });
  mesh.onDroppedConnection(
      [](size_t id) { Serial.printf("[mesh] -Node %u\n", (uint32_t)id); });
  mesh.stationManual(STATION_SSID,
                     STATION_PASSWORD); // ← key: mesh owns the STA
  mesh.setHostname("ais-gateway");

  // 2. TLS client — setInsecure() skips cert check (ok for dev)
  wifiClient.setInsecure();
  wifiClient.setTimeout(5);
  mqttClient.setServer(MQTT_HOST, MQTT_PORT_TLS);
  mqttClient.setCallback(mqttCallback);
  mqttClient.setKeepAlive(30);
  mqttClient.setSocketTimeout(5);
  mqttClient.setBufferSize(512);

  Serial.println("[gw] Gateway started — waiting for IP...");
}

// ─── Loop ────────────────────────────────────────────────────────────────────
void loop() {
  mesh.update();     // must run every iteration
  mqttClient.loop(); // process keep-alive / incoming

  // Connect (or reconnect) to MQTT whenever the station IP changes.
  // This is the official painlessMesh bridge pattern — no blocking delay().
  IPAddress ip = getStationIP();
  if (ip != myIP) {
    myIP = ip;
    Serial.printf("[wifi] IP: %s\n", myIP.toString().c_str());

    if (myIP != IPAddress(0, 0, 0, 0)) {
      Serial.print("[mqtt] Connecting... ");
      String clientId = "gw-" + String(ESP.getChipId(), HEX);
      if (mqttClient.connect(clientId.c_str(), MQTT_USER, MQTT_PASS)) {
        Serial.println("OK");
        // Publish gateway online status
        String statusTopic = String(T_VERSION) + "/" + T_TENANT + "/" +
                             T_INDUSTRY + "/" + T_SITE + "/" + T_GATEWAY +
                             "/status";
        mqttClient.publish(statusTopic.c_str(), "{\"state\":\"online\"}");
      } else {
        Serial.printf("[mqtt] Failed (rc=%d)\n", mqttClient.state());
      }
    }
  }

  // Non-blocking reconnect if MQTT dropped after initial connect
  if (myIP != IPAddress(0, 0, 0, 0) && !mqttClient.connected()) {
    unsigned long now = millis();
    if (now - lastMqttAttempt > 5000) {
      lastMqttAttempt = now;
      Serial.print("[mqtt] Reconnecting... ");
      String clientId = "gw-" + String(ESP.getChipId(), HEX);
      if (mqttClient.connect(clientId.c_str(), MQTT_USER, MQTT_PASS)) {
        Serial.println("OK");
      } else {
        Serial.printf("[mqtt] Failed (rc=%d)\n", mqttClient.state());
      }
    }
  }
}

Conclusion

Though this is very complex in terms of code. It is very efficient in terms of power and data consumption.

If you have any questions or suggestions, please feel free to ask in the comments section.

I will be going indetail how these both sender and receiver works in my next article.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

DEV Community: Ganesh Kumar

How to Secure Nomad?

Enable ACL in Nomad

Generate Security Token for Nomad

Create Policy for Users

Conclusion

How to Configure Nginx as a Proxy Server?

Setting Up a Simple Proxy Server

Add Static Files For Existing Proxy Server

Conclusion

How to Expose Localhost to the Public Using Nginx and SSH Tunnels

The Architecture

Step 1: The Remote Server (Nginx)

Step 2: The Local Bridge

Why this is "Unlimited"

Troubleshooting Common Gotchas

Conclusion

How Do Smart Devices Perform Multiple Tasks?

How will the task be performed?

How will a normal loop cause a problem?

Adding Other Operations in a loop

What is Task Scheduler?

Core Logic of Task Scheduler

Using Task Scheduler

How real world devices use task scheduler

Conclusion

How does SSH work and how can it be set up?

How SSH Works

1. The Handshake

2. Authentication

3. Encryption Layers

How to Setup SSH

Step 1: Install the SSH Server

Step 2: Generate SSH Keys (Recommended)

Step 3: Copy the Key to the Server

Step 4: Connect

Conclusion

How to Configure and Control Nginx?

Understanding Nginx Controls

Configure Nginx

Conclusion

How Nginx Architecture is Designed and How They Work

How Nginx Architecture and How they Works?

How to Start, Stop and Reload Nginx?

Conclusion

How to Connect a DHT11 to a NodeMCU v2 board?

Hardware Check

Power Compatibility

Hardware Identification

Step-by-Step Wiring Guide

For the 4-Pin Bare Sensor

For the 3-Pin Module

Why the Pull-up Resistor Matters?

Coding Your DHT11 with PlatformIO

1. Configure platformio.ini

2. The Main Code (src/main.cpp)

Key Adjustments for the DHT11

Conclusion

Why is Nginx configuration organized as sites-available and sites-enabled?

How are ngix config files organized?

How to write site configuration file?

How to enable the site?

How to disable the site?

Conclusion

How to use Task Scheduler in ESP8266?

Core Logic of Task Scheduler

Using Task Scheduler

Conclusion

How to perform multiple operations in the ESP8266?

How Operations are performed in ESP8266?

How Normal Loop will cause problem?

Adding Other Operation in loop

What is Task Scheduler?

Conclusion

How to Send Data from PainlessMesh to the Cloud Using MQTT in an ESP8266?

What Problem we are solving?

How it works?

Conclusion

1. Configure `platformio.ini`

2. The Main Code (`src/main.cpp`)