IoT Architectures

Modern IoT systems are not simple point-to-point connections between a sensor and a server. They rely on a layered computational architecture that decides where data is processed, stored, and acted upon. Understanding IoT architecture layers is fundamental for designing scalable, low-latency, and energy-efficient IoT systems.

Core Concept Explanation

IoT architecture is typically described in three primary layers. The perception layer sits at the bottom and includes all physical devices like sensors, actuators, microcontrollers, and communication hardware. This is where raw data originates from the physical world.

Above the perception layer sits the network or transport layer, which handles data transmission between devices and processing nodes. Protocols like MQTT, CoAP, WiFi, Zigbee, and BLE operate at this layer to carry data across different network types.

The topmost is the application layer, where data is processed, stored, and presented to end users or automated decision systems. Cloud platforms like AWS IoT, Azure IoT Hub, and Google Cloud IoT operate here.

Edge, Fog, and Cloud Computing in IoT

In more advanced models, two additional computational tiers are inserted between devices and the cloud. Edge computing places computation directly at or near the device. Processing happens on a microcontroller or single-board computer before data leaves the local environment. This drastically reduces latency and saves bandwidth.

Fog computing extends edge computing by introducing intermediate nodes such as local servers, routers with compute capability, or industrial PCs within a facility. Fog nodes aggregate data from multiple edge devices, apply filtering or lightweight analytics, and then forward only relevant data to the cloud.

Cloud computing handles heavy analytics, long-term storage, machine learning inference, and dashboards. The cloud receives pre-processed, filtered data rather than raw streams, making it both cost-effective and scalable.

Mathematical Expression

One key metric in architecture design is latency. Total end-to-end latency can be expressed as:

Total Latency = t_sense + t_transmit + t_process + t_respond

Edge computing reduces t_transmit and t_process by keeping computation local. If cloud round-trip adds 200ms but edge processing takes only 5ms, the system latency drops by over 97%. This is critical for real-time applications like industrial automation and autonomous vehicles.

Practical Understanding

Consider a smart factory with 500 vibration sensors monitoring motors. If every raw sample is sent to the cloud at 1 kHz, the bandwidth demand becomes enormous. With edge processing, each sensor node detects anomalies locally and only sends an alert flag every few seconds. The fog layer aggregates alerts from a zone of 50 machines and sends a structured report to the cloud every minute. The cloud then runs predictive maintenance models.

This layered processing is what makes large-scale IoT deployment practical. Without it, cloud costs, bandwidth, and latency make real-time IoT infeasible.

Given:
100 sensors each sending 1 KB data every 100ms to cloud directly
With fog layer: only 1 aggregated packet of 2 KB per second per zone (10 sensors per zone)

Why this formula applies:
Bandwidth = Number of sources x Data rate per source

Formula:
BW = N x (data_size / interval)

Substitution (without fog):
BW = 100 x (1 KB / 0.1 s) = 100 x 10 KB/s = 1000 KB/s = 1 MB/s

Substitution (with fog, 10 zones):
BW = 10 zones x (2 KB / 1 s) = 20 KB/s

Calculation:
Reduction factor = 1000 / 20 = 50x

Final Answer: Fog layer reduces cloud-bound bandwidth by 50x in this scenario.

Exam Tip: In GATE and university exams, edge computing is associated with lowest latency and local decision-making, while fog is the intermediate tier. Do not confuse fog with cloud — fog nodes are geographically distributed and closer to devices.

Architecture Tiers Compared

• Edge: Processing at or within the device itself. Minimum latency, limited compute, no internet required.
• Fog: Intermediate local servers or smart gateways. Aggregates edge data, reduces cloud load.
• Cloud: Centralized processing. Unlimited storage and compute, high latency, internet-dependent.
• Three-layer model (Perception, Network, Application) is the foundational architecture view.
• Five-layer model adds Business Layer and Processing Layer for enterprise IoT systems.

Quick Revision

• Three IoT layers: Perception (devices), Network (transport), Application (analytics/UI).
• Edge computing: computation at the device, lowest latency, minimum bandwidth usage.
• Fog computing: intermediate nodes between edge and cloud, zone-level aggregation.
• Cloud: centralized, heavy analytics, high latency, best for batch processing and ML.
• Latency formula: t_total = t_sense + t_transmit + t_process + t_respond.
• Fog reduces cloud bandwidth significantly by pre-filtering and aggregating data.
• Trap: Fog is NOT the same as cloud. Fog is distributed and geographically close to devices.