← Back to Guides | Portfolio Home

IoT Sensors Deep Dive: Analog-to-Digital, Protocols, and Backhaul


Last updated: February 26, 2026
Author: Paul Namalomba
- SESKA Computational Engineer
- SEAT Backend Developer
- Software Developer
- PhD Candidate (Civil Engineering Spec. Computational and Applied Mechanics)
Contact: kabwenzenamalomba@gmail.com
Website: paulnamalomba.github.io

Hardware License: MIT

Overview

This guide details the end-to-end architecture of Internet of Things (IoT) sensors, spanning from raw hardware data acquisition to cloud-based ETL pipelines. It covers the crucial mechanics of Analog-to-Digital Conversion (ADC), network telemetry protocols (MQTT vs. HTTP), internet backhaul strategies, and large-scale data tunneling.

Contents

1. Configuration (Windows & Linux)

Setting up an IoT development environment requires configuring toolchains capable of cross-compiling code for embedded architectures (ARM, ESP32, AVR).

Linux (Debian/Ubuntu) Strategy

Linux provides the most predictable environment for embedded toolchains and serial communication.

# Install the GCC ARM cross-compiler and essential build tools
sudo apt update && sudo apt install -y build-essential gcc-arm-none-eabi

# Add user to the dialout group to allow flashing over USB/Serial
sudo usermod -a -G dialout $USER

# Install Python packages required by most modern build systems (like PlatformIO or Espressif IDF)
pip3 install pyserial platformio

Windows Strategy

Windows development requires strict path management and driver installations (usually CP210x or CH340 for USB-to-UART bridges). Toolchains are best managed via PlatformIO within VS Code to bypass native environment pathing nightmares.

Key Config Files: * /etc/udev/rules.d/: On Linux, defining udev rules ensures predictable mounting of serial devices (e.g., mapping a specific sensor to /dev/ttySensor). * platformio.ini: The central configuration file for modern embedded projects, specifying the target board, framework (Arduino vs. ESP-IDF), upload ports, and baud rates.

2. Writing Basic Code/Scripts (ADC & Telemetry)

The code lifecycle of an edge sensor dictates reading raw analog voltage, converting it to a discrete digital value via an ADC, synthesizing a payload, and pushing it out via a network protocol like MQTT or HTTP.

Analog-to-Digital Conversion (ADC)

An ADC maps continuous voltage variations to discrete integer values based on its bit resolution (e.g., a 12-bit ADC provides 4096 discrete steps).

#include <Arduino.h>

#define SENSOR_PIN 34  // Analog pin
#define ADC_RESOLUTION 4095.0 // 12-bit ADC
#define V_REF 3.3      // Reference voltage

void setup() {
    Serial.begin(115200);
    analogReadResolution(12); // Enforce 12-bit resolution
}

void loop() {
    int rawValue = analogRead(SENSOR_PIN);
    // Convert raw integer back into a physical voltage
    float voltage = (rawValue / ADC_RESOLUTION) * V_REF;

    // Derived physical metric calculation (e.g., Temperature mapping)
    float temperatureC = (voltage - 0.5) * 100.0; 

    Serial.printf("Raw: %d, Volts: %.2fV, Temp: %.2f°C\n", rawValue, voltage, temperatureC);
    delay(2000);
}

Network Protocols: MQTT vs. HTTP

While HTTP requires significant overhead via headers and establishing new TCP sockets per request, MQTT is the industry standard for IoT. MQTT maintains a persistent, lightweight TCP connection to a broker, publishing tiny packets asynchronously on defined "topics."

import paho.mqtt.client as mqtt
import json

BROKER = "mqtt.enterprise.internal"
CLIENT_ID = "Sensor_A1"

def on_connect(client, userdata, flags, rc):
    print(f"Connected to backhaul with result code {rc}")

client = mqtt.Client(client_id=CLIENT_ID)
client.on_connect = on_connect
client.connect(BROKER, 1883, 60)

# Tunneling payload
payload = json.dumps({
    "device_id": CLIENT_ID,
    "temperature": 24.5,
    "timestamp": 1709088421
})

# Publish to topic with Quality of Service (QoS) 1 (At least once delivery)
client.publish("telemetry/facility1/hvac", payload, qos=1)
client.loop_start()

3. Compile-time Commands (Firmware Generation)

Microcontrollers do not possess a runtime engine capable of interpreting raw source code. The code must be compiled, linked, and assembled into a .bin or .hex binary payload specific to the target silicon architecture.

Using PlatformIO:

# Clean previous build artifacts
pio run --target clean

# Compile the firmware for the target defined in platformio.ini
pio run

# Compile and upload over the serial port to the physical hardware
pio run --target upload

Pre-execution analysis: The compiler performs strict static typing and memory allocation checks. Because microcontrollers possess kilobytes (not gigabytes) of RAM, dynamic allocation (malloc or new) is highly discouraged. The compiler generates memory maps indicating .bss and .data segment usage to prevent stack collisions.

4. Runtime Commands (Daemonization & ETL Backhaul)

While the edge devices execute firmware continuously in an infinite loop(), the receiving end—the telemetry backhaul—must daemonize its ingestion services to catch the datastream without interruption.

Internet Backhaul

Managing massive volumes of telemetry from edge gateways requires queueing systems. Services like Mosquitto (MQTT Broker) must run reliably under the system supervisor.

# Enable the MQTT broker daemon on Ubuntu
sudo systemctl enable mosquitto
sudo systemctl start mosquitto

# Check ingestion bandwidth
netstat -tulpn | grep 1883

Tunneling Data Streams into ETL Pipelines

Once telemetry reaches the broker, a subscriber daemon immediately extracts, transforms, and loads (ETL) it into a timeseries database (like TimescaleDB or InfluxDB).

# Running an ingestion worker script as a background daemon
nohup python3 /opt/telemetry/ingestion_worker.py > /var/log/iot/ingestion.log 2>&1 &

# Better approach: Establish a Systemd Service for the ETL worker
# /etc/systemd/system/etl-worker.service

5. Debugging (Radio Silence & Data Loss)

Because hardware fails without throwing stack traces to a terminal, debugging IoT infrastructure relies heavily on signal persistence tools and log aggregation. Nothing builds character quite like deciphering why an I2C bus locked up purely because a pull-up resistor was rated 1k Ohm instead of 4.7k Ohm.

Edge Debugging

  • Serial Monitors: Hooking a USB cable directly to the UART bridge is your primary window into the microcontroller. bash pio device monitor --baud 115200
  • Common Pitfalls: Ground loops introducing analog noise to the ADC, resulting in erratic sensor readings. Always tie sensor grounds directly to the microcontroller logic ground.

Backhaul Debugging

  • Topic Snooping: Subscribe to the wildcard topic # to verify data is actually hitting the network layer. bash mosquitto_sub -h localhost -t "#" -v
  • Log Check: Tracebacks indicating connection drops (EOF or TCP timeouts) generally indicate poor signal strength at the edge or excessively aggressive keep-alive timers. bash tail -f /var/log/mosquitto/mosquitto.log