712  RPL Specification and Core Concepts

712.1 RPL Specification

• Standard: RFC 6550 (IETF, March 2012)
• Type: Distance-vector routing protocol
• Network Layer: IPv6 (works with 6LoWPAN)
• Topology: DODAG (Destination Oriented Directed Acyclic Graph)
• Metrics: Flexible (hops, ETX, latency, energy, etc.)
• Use Case: Low-power, lossy networks with many-to-one traffic patterns

712.2 Why Not Use Existing Routing Protocols?

Traditional routing protocols like OSPF, RIP, and AODV were designed for different network characteristics. They don’t work well for IoT because:

712.2.1 Processing, Memory, and Power Constraints

Graph diagram

Figure 712.1: Traditional router vs IoT sensor constraint incompatibility

{fig-alt=“Comparison showing traditional router requirements (GHz CPU, GB RAM, watts power, complex tables) versus IoT sensor constraints (32 MHz CPU, 32 KB RAM, milliwatts battery, parent pointer only) highlighting incompatibility”}

Traditional Protocols Require: - Complex routing tables: OSPF maintains link-state database of entire network - Frequent updates: RIP sends entire routing table every 30 seconds - Heavy processing: Link-state algorithms (Dijkstra’s shortest path) - Power-hungry: Constant listening and periodic broadcasts

IoT Constraints: - Microcontroller: 8-32 MHz, single core - RAM: 10-128 KB (vs GB in traditional routers) - Flash: 32-512 KB (limited code and data storage) - Power: Milliwatts (battery-powered, years of operation)

712.2.2 Single Metric Not Always Appropriate

Traditional protocols use single metric: - RIP: Hop count only - OSPF: Cost (usually based on bandwidth)

IoT requires multiple, context-dependent metrics: - Latency: Real-time monitoring (industrial sensors) - Reliability: Critical data (medical devices) - Energy: Battery-powered devices (maximize lifetime) - Bandwidth: Mixed traffic (sensors + actuators)

RPL Solution: Supports objective functions with multiple metrics

712.2.3 Multiple Routing Instances

IoT Scenario: Single physical network, multiple applications

Graph diagram

Figure 712.2: Multiple RPL instances with different optimization goals

{fig-alt=“Multiple RPL instances on same physical network: Instance 1 optimizes for latency (temperature monitoring) with fast parent selection, Instance 2 optimizes for energy (firmware updates) with low-power parent selection”}

Example: - Instance 1: Temperature monitoring (minimize latency) - Instance 2: Firmware updates (minimize energy, can be slower) - Same devices, different routing decisions based on application

712.2.4 Point-to-Multipoint Traffic Patterns

Traditional networks: Assume peer-to-peer traffic

IoT networks: Predominantly many-to-one traffic - Many sensors → One gateway (cloud) - Data aggregation at root

RPL Optimization: Optimized for convergent traffic towards root

712.2.5 Lossy Links

Traditional networks: Assume reliable links (wired, enterprise Wi-Fi)

Low-Power and Lossy Networks (LLN): - High packet loss: 10-40% (vs < 1% wired) - Variable link quality: Interference, fading, obstacles - Asymmetric links: A can hear B, but B can’t hear A - Time-varying: Link quality changes over time

RPL Features for Lossy Networks: - Trickle timer: Adaptive control message frequency - ETX metric: Expected Transmission Count (accounts for retransmissions) - Loop avoidance: RANK prevents routing loops

NoteUnderstanding Check: DODAG Loop Prevention

Scenario: You’re debugging an agricultural IoT network with 100 soil moisture sensors across 5 km². During a storm, several sensors lose connectivity and attempt to rejoin the network. Without proper loop prevention, sensors could form routing cycles where packets endlessly circulate.

Think about: - What happens if Sensor C (RANK 370) tries to select Sensor E (RANK 500) as its parent? - How does RPL prevent packets from bouncing between nodes indefinitely? - Why can’t traditional protocols like RIP handle this as efficiently?

Key Insight: RPL’s DODAG (Directed Acyclic Graph) structure enforces that RANK strictly increases as you move away from the root. A node at RANK 370 cannot select a parent with RANK 500 (higher rank). By definition, if you always forward to lower RANK, you eventually reach RANK 0 (root)—cycles are mathematically impossible.

Real-world metrics: In your 100-sensor network, each sensor stores only its parent pointer (~4 bytes) instead of full routing tables (~10 KB for 100 nodes). When Node C’s parent fails, it checks neighbors’ DIOs: “Node A RANK 250 ✓ (lower), Node E RANK 500 ✗ (higher).” Simple comparison, no complex loop detection needed.

Verify Your Understanding: Traditional distance-vector protocols like RIP suffer “count-to-infinity” during failures (routing metric keeps incrementing: 1→2→3…→∞). How does RPL’s RANK mechanism bound this problem? (Answer: Maximum RANK is limited by objective function; nodes at max RANK cannot increase further, forcing them to find alternate parents or go offline instead of counting to infinity)

NoteUnderstanding Check: Distance-Vector vs Link-State for IoT

Scenario: You’re comparing two routing approaches for a factory with 50 vibration sensors monitoring machinery. Option A (link-state like OSPF) requires each sensor to maintain a map of all 50 sensors and 80 connections. Option B (distance-vector like RPL) only requires storing: “My parent is Node 7, cost is 150.”

Think about: - How much memory does each sensor need for Option A vs Option B? - When a new sensor joins, which approach requires less communication overhead? - What’s the trade-off between local knowledge and network-wide visibility?

Key Insight: RPL is distance-vector: each node knows “next hop” (parent) and “distance” (RANK/cost) to root, but NOT the complete network topology. This minimal state fits in constrained devices (8 KB RAM typical for IoT sensors).

Real-world comparison: - Distance-vector (RPL): Node E stores: “Parent=D, RANK=768, Cost=120” (12 bytes) - Link-state (OSPF): Node E stores: Complete topology graph for 50 nodes × 80 links × 16 bytes/entry = 64 KB (exceeds sensor RAM!)

Why “distance-vector” name: “Distance” = RANK value (metric space distance to root). “Vector” = direction (points to parent/next-hop). Node doesn’t compute paths using Dijkstra—it trusts parent’s advertised distance.

Verify Your Understanding: If a link quality changes in the middle of the network, how does each approach detect it? (Answer: Distance-vector learns slowly via neighbor advertisements propagating; Link-state floods update immediately to all nodes. RPL accepts slower convergence for lower overhead—acceptable for IoT where topology changes are infrequent)

712.3 RPL Core Concepts

712.3.1 Directed Acyclic Graph (DAG)

DAG = Directed Acyclic Graph

Graph diagram

Figure 712.3: DAG structure with directed edges and no cycles

{fig-alt=“Directed Acyclic Graph (DAG) example showing nodes A through E connected with directed arrows flowing downward, demonstrating no cycles - cannot return to same node following edges”}

Key Properties: - Directed: Edges have direction (arrows) - Acyclic: No cycles (cannot return to same node following edges) - Graph: Nodes connected by edges

Why DAG? - Loop-free routing: By definition, no cycles = no routing loops - Hierarchical structure: Natural parent-child relationships - Efficient aggregation: Data flows towards root(s)

712.3.2 DODAG (Destination Oriented DAG)

RPL uses DODAG: DAG with single root (destination)

Graph diagram

Figure 712.4: DODAG with single root and RANK-based hierarchy

{fig-alt=“Destination Oriented Directed Acyclic Graph (DODAG) with single ROOT node at top (Rank 0), intermediate nodes at Rank 256 and 512, leaf nodes at Rank 768, all paths flowing toward root”}

RPL DODAG Structure

Figure 712.5: The DODAG (Destination-Oriented Directed Acyclic Graph) forms the core routing structure in RPL networks. Nodes select preferred parents based on rank values calculated using an objective function, creating loop-free paths that efficiently route all traffic toward the root (typically a border router connecting to the internet).

DODAG Properties: - Single root: One destination (typically border router/gateway) - Upward routes: All paths lead to root - RANK: Position in DODAG hierarchy (root = 0, increases going down)

712.3.3 RANK: Loop Prevention Mechanism

RANK is a scalar representing a node’s position relative to the root.

Graph diagram

Figure 712.6: RANK-based loop prevention with forbidden backward paths

{fig-alt=“RANK loop prevention mechanism showing ROOT at Rank 0, Node A at 100, B at 250, C at 370, with valid forward links and forbidden backward link from C to A that would create a loop”}

RANK Rules: 1. Root has RANK 0 (or minimum RANK) 2. RANK increases as you move away from root 3. Upward routing: Packets forwarded to nodes with lower RANK 4. Loop prevention: Node cannot choose parent with higher RANK

RANK Calculation:

RANK(node) = RANK(parent) + RankIncrease

RankIncrease calculated based on:
- Link cost (ETX, RSSI, etc.)
- Number of hops
- Energy consumed
- Objective function

Example:

ROOT: RANK = 0
Node A (parent: ROOT): RANK = 0 + 100 = 100
Node B (parent: Node A): RANK = 100 + 150 = 250
Node C (parent: Node B): RANK = 250 + 120 = 370

Loop Prevention: - Node C cannot choose Node A as parent (RANK 100 < 370 is OK) - Node A cannot choose Node C as parent (RANK 370 > 100 - would create loop)

ImportantRANK vs Hop Count

RANK ≠ Hop Count (although hop count can be a factor)

RANK is calculated using objective function which may consider: - Hop count - Expected Transmission Count (ETX) - Latency - Energy consumption - Link quality (RSSI, LQI)

Example: - Good link, 1 hop: RANK increase = 100 - Poor link, 1 hop: RANK increase = 300 - Good link, 2 hops: RANK increase = 200

Node may prefer 2 hops via good links (total RANK increase: 200) over 1 hop via poor link (RANK increase: 300).

712.4 What’s Next

Continue to the next section to learn how DODAGs are actually constructed:

• RPL DODAG Construction: Step-by-step DODAG formation process
• RPL Routing Modes: Storing vs Non-Storing trade-offs
• RPL Summary and Tools: Common pitfalls and interactive demos
• RPL Overview: Return to fundamentals and introduction