Industrial Telemetry Synchronization with MQTT-SN Protocols in Edge Environments with Intermittent Connectivity

The Connectivity Challenge in Remote Industrial Plants

In modern control engineering, collecting data from sensors scattered across a factory is the foundation of any efficient operation. However, in outdoor areas, offshore platforms, or isolated substations, the internet is far from being a stable and continuous fiber-optic cable. In these scenarios, intermittent connectivity—meaning connections that drop and return without prior notice—turns simple temperature or pressure readings into an engineering puzzle. In practice, this means a data packet can get lost halfway if the system is not prepared to handle network silence.

When the network fails, traditional systems usually accumulate errors or simply discard information vital to machinery safety. To solve this problem, system architecture must decentralize, moving processing to the edge of the network. Edge computing consists of placing small computers or microcontrollers directly near sensors, allowing them to make local decisions and keep information until the path to the central server is clear again. Without this strategy, any network fluctuation would paralyze the production line or blind operators to imminent failures in expensive motors.

Understanding MQTT-SN for Low-Power Networks

To communicate low-power devices operating in unstable networks, the traditional MQTT protocol—widely used in the internet of things—can still be too heavy. This is where MQTT-SN comes in, a variation designed specifically for wireless sensor networks, where SN stands for Sensor Network. In practice, it works as a compacted version of the common protocol, optimized to save bandwidth and battery life of remote equipment that operates for years without battery changes. It reduces message header sizes and elegantly handles the fact that many industrial radios have limited range and heavy interference.

One of MQTT-SN's tricks is support for clients we call sleeping clients. An isolated tank level sensor, for example, can spend ninety percent of the day with its radio off to save energy, waking up only for fractions of a second to send its status. The protocol manages this routine by storing messages in an intermediate component called an MQTT-SN gateway, which translates lightweight wireless packets into the conventional MQTT standard that the cloud understands. Thus, the central infrastructure sees the sensor as if it were connected all the time, even if the physical equipment is hibernating most of the time.

Local Storage Architecture and Edge Recovery

When the connection to the central server drops completely, the edge gateway acts as a data safe. Using circular buffers in the device's flash memory ensures that continuous sensor readings are not lost during a network blackout. In practice, a circular buffer works like a ring-shaped factory conveyor belt: when space runs out, the oldest data that has already been sent starts being overwritten by new data. If the network drops, the system keeps recording new boxes on the belt until it fills up or connection returns.

The synchronization logic kicks in as soon as the internet link stabilizes. The gateway initiates a batch transmission routine, sending accumulated packets in chronological order to the central server, ensuring no telemetry history is corrupted. To prevent the server from suffering a data bottleneck after reconnection, we implement flow control algorithms and exponential backoff retries. In practice, this prevents the system from trying to resend everything at once, which could crash the network again due to excessive traffic.

Practical Implementation of an Edge Client

Below we present a functional C example, very common in industrial microcontrollers based on ESP32 or similar architectures, demonstrating the basic routine of publishing telemetry with reconnection handling and simulated local storage.

#include <stdio.h>
#include <stdbool.h>
#include <unistd.h>

#define BUFFER_SIZE 10

typedef struct {
    int id;
    float temperatura;
} TelemetriaDado;

TelemetriaDado bufferLocal[BUFFER_SIZE];
int cabeca = 0;
int cauda = 0;
int totalArmazenado = 0;

bool estaConectadoNaRede() {
    // Simulates checking connectivity with the central server
    return false;
}

void salvarNoBufferLocal(int id, float temp) {
    bufferLocal[cabeca].id = id;
    bufferLocal[cabeca].temperatura = temp;
    cabeca = (cabeca + 1) % BUFFER_SIZE;
    if (totalArmazenado < BUFFER_SIZE) {
        totalArmazenado++;
    } else {
        cauda = (cauda + 1) % BUFFER_SIZE; // Overwrites the oldest
    }
}

void enviarParaServidor(TelemetriaDado dado) {
    printf("Sent successfully -> ID: %d, Temp: %.2f C
", dado.id, dado.temperatura);

}>

void sincronizarDados() {
    while (totalArmazenado > 0 && estaConectadoNaRede()) {
        enviarParaServidor(bufferLocal[cauda]);
        cauda = (cauda + 1) % BUFFER_SIZE;
        totalArmazenado--;
    }
}

int main() {
    int idSensor = 101;
    float leituraTemp = 74.5f;

    for (int i = 0; i < 3; i++) {
        if (estaConectadoNaRede()) {
            enviarParaServidor((TelemetriaDado){idSensor, leituraTemp});
        } else {
            printf("Unstable network! Saving data to local buffer.
");
            salvarNoBufferLocal(idSensor, leituraTemp);
        }
        leituraTemp += 1.2f;
        sleep(1);
    }

    sincronizarDados();
    return 0;
}

Final Thoughts on Industrial Reliability

Building resilient systems in industrial environments requires abandoning the illusion that the network will always be available. The integration between the MQTT-SN protocol and robust edge storage strategies turns potential points of failure into an autonomous and secure operation. When field software understands its own connectivity limitations, it starts acting preventively, storing what matters and delivering data as soon as the scenario normalizes.

Ultimately, investing in this architecture reduces corrective maintenance costs and raises the operational reliability of entire plants. The secret of modern engineering is not just building faster connections, but designing systems that know exactly what to do when the connection simply disappears.