84  802.15.4 Quiz: Addressing

In 60 Seconds

IEEE 802.15.4 addressing trades flexibility for overhead within a 127-byte frame: choosing 16-bit short addresses over 64-bit extended addresses saves 12 bytes per frame, compounding into significant battery life differences across thousands of transmissions. The Cskip tree addressing algorithm enables distributed address assignment without centralized coordination.

Key Concepts

• PAN ID: 16-bit identifier distinguishing one 802.15.4 network from another; included in frame headers for inter-PAN filtering
• Short Address (16-bit): Compressed network address assigned by coordinator during association; reduces frame overhead to 2 bytes
• Extended Address (EUI-64): 64-bit globally unique manufacturer-assigned address; used before association and for long-distance addressing
• Addressing Mode Field: 2-bit field in frame control specifying whether each address is absent, 16-bit, or 64-bit
• Intra-PAN Compression: Omitting the destination PAN ID when source and destination are in the same PAN, saving 2 bytes
• Cskip Formula: Distributes 16-bit address blocks to tree nodes: \(C_{skip}(d) = 1 + C_m(L_m - d - 1) imes R_m^{L_m-d-1}\)
• Broadcast Address: 0xFFFF reserved as the short address for broadcast to all devices in a PAN
• Coordinator Short Address: 0x0000 reserved for the PAN coordinator’s short address

84.1 Minimum Viable Understanding

IEEE 802.15.4 addressing is a trade-off between flexibility and overhead within a 127-byte frame. Choosing 16-bit short addresses over 64-bit extended addresses saves 12 bytes per frame, which compounds into significant battery life and bandwidth differences across thousands of transmissions. The Cskip tree addressing algorithm enables distributed address assignment without centralized coordination, allocating contiguous address blocks hierarchically based on network depth and branching parameters (Lm, Cm, Rm).

84.2 Learning Objectives

After completing this quiz section, you should be able to:

1. Evaluate which IEEE 802.15.4 addressing mode minimizes overhead for a given network scenario
2. Derive address space allocations using the Cskip tree addressing algorithm with specific Lm, Cm, and Rm parameters
3. Calculate superframe timing parameters (beacon interval, active duration, duty cycle) from SO and BO values
4. Contrast FFD and RFD device architectures in terms of memory footprint, routing capability, and deployment role

For Beginners: 802.15.4 Addressing Quiz

This quiz tests your understanding of how 802.15.4 devices are identified and addressed on a network. Just as every house has a street address, every wireless device has a network address. These questions help you confirm you understand the addressing schemes that make low-power wireless communication possible.

Navigation

Return to: Quiz Bank Part 1 Overview

Other Quiz Sections:

• Addressing and Network Structure (Current)
• Power and Performance Calculations
• Device Types and Security

Study Materials:

• 802.15.4 Fundamentals - Core concepts
• 802.15.4 Topic Review - Quick reference

84.3 Quiz: Addressing Modes

84.3.1 Mid-Section Check: Address Overhead Impact

84.4 Quiz: Tree Addressing (Cskip Algorithm)

84.5 Quiz: Superframe Timing Calculation

84.6 Quiz: FFD vs RFD Memory Requirements

84.7 Interactive Knowledge Checks

84.7.1 Knowledge Check: Addressing Overhead Impact

84.7.2 Knowledge Check: Superframe Duty Cycle

84.8 Interactive: Cskip Address Calculator

viewof lm_param = Inputs.range([2, 6], {value: 4, step: 1, label: "Lm (max depth)"})
viewof cm_param = Inputs.range([2, 20], {value: 8, step: 1, label: "Cm (max children per parent)"})
viewof rm_param = Inputs.range([1, 10], {value: 3, step: 1, label: "Rm (max routers per parent)"})

{
  function cskip(d, lm, cm, rm) {
    if (d >= lm - 1) return 1;
    return 1 + cm * cskip(d + 1, lm, cm, rm);
  }
  const levels = [];
  for (let d = 0; d < lm_param; d++) {
    const cs = cskip(d, lm_param, cm_param, rm_param);
    levels.push({depth: d, cskip_val: cs});
  }
  const total_addr = levels[0].cskip_val;
  const fits_16bit = total_addr < 65535;

  return html`<div style="background:#f8f9fa; border-left:4px solid ${fits_16bit ? '#16A085' : '#E74C3C'}; padding:16px; border-radius:4px; font-family:Arial,sans-serif;">
    <table style="width:100%; border-collapse:collapse; margin-bottom:8px;">
      <tr style="background:#2C3E50; color:white;">
        <th style="padding:6px;">Depth</th><th style="padding:6px;">Cskip Value</th><th style="padding:6px;">Role</th>
      </tr>
      ${levels.map(l => `<tr style="border-bottom:1px solid #ddd;">
        <td style="padding:6px; text-align:center;">${l.depth}</td>
        <td style="padding:6px; text-align:center; font-weight:bold; color:#3498DB;">${l.cskip_val}</td>
        <td style="padding:6px;">${l.depth === 0 ? "PAN Coordinator" : l.depth === lm_param - 1 ? "Leaf devices" : "Router (level " + l.depth + ")"}</td>
      </tr>`).join('')}
    </table>
    <div><strong style="color:#2C3E50;">Total address space:</strong> ${total_addr} addresses</div>
    <div><strong style="color:#2C3E50;">Fits in 16-bit space (65,535)?</strong> <span style="color:${fits_16bit ? '#16A085' : '#E74C3C'}; font-weight:bold;">${fits_16bit ? 'Yes' : 'No -- exceeds 16-bit address space!'}</span></div>
    <div style="margin-top:4px; font-size:0.85em; color:#7F8C8D;">Adjust Lm, Cm, Rm to see how address space scales. Large Cm or deep Lm can exhaust the 16-bit address range.</div>
  </div>`;
}

Worked Example: Cskip Tree Addressing in Smart Building

Scenario: A 10-story office building deploys an 802.15.4 mesh network with hierarchical addressing using the Cskip algorithm. The network has specific depth and branching limits.

Network Parameters:

• Lm (maximum depth) = 4 levels
• Cm (maximum children per parent) = 8
• Rm (maximum routers per parent) = 3

Building Topology:

Level 0: PAN Coordinator (basement network closet)
Level 1: Floor routers (10 floors x 1 router = 10 FFDs)
Level 2: Zone routers (each floor has 3 zones = 30 FFDs)
Level 3: End devices (sensors/actuators = RFDs)
Level 4: Not used (Lm=4, but level 3 is leaf)

Step 1: Calculate Cskip Values

Cskip formula: Cskip(d) = 1 + Cm x (Cskip(d+1)) for depth d < Lm-1

For Level 3 (leaf level, d=3):

Cskip(3) = 1 (leaf nodes assign no addresses)

For Level 2 (d=2):

Cskip(2) = 1 + Cm x Cskip(3)
Cskip(2) = 1 + 8 x 1
Cskip(2) = 9

Each level-2 router can allocate addresses for:
- 8 children (Cm=8)
- Each child gets 1 address (since they're RFD leaves)

For Level 1 (d=1):

Cskip(1) = 1 + Cm x Cskip(2)
Cskip(1) = 1 + 8 x 9
Cskip(1) = 73

Each level-1 router can allocate addresses for:
- 8 children total
- Up to 3 of them can be routers (Rm=3)
- Each router child gets Cskip(2)=9 addresses
- Each end-device child gets 1 address

For Level 0 (PAN Coordinator, d=0):

Cskip(0) = 1 + Cm x Cskip(1)
Cskip(0) = 1 + 8 x 73
Cskip(0) = 585

PAN Coordinator reserves 585 addresses for its subtree

Step 2: Assign Addresses - Example for Floor 1

PAN Coordinator: Address 0x0000

Floor 1 Router (first child of coordinator):

Address = Parent + 1 = 0x0000 + 1 = 0x0001
Address range for subtree: 0x0001 to 0x0049 (73 addresses)

Floor 1, Zone A Router (first router child of floor router):

Address = Parent + 1 = 0x0001 + 1 = 0x0002
Address range: 0x0002 to 0x000A (9 addresses for its children)

Floor 1, Zone A, Sensor 1 (first end-device child):

Address = Parent + 1 = 0x0002 + 1 = 0x0003

Floor 1, Zone A, Sensor 2 (second end-device child):

Address = Parent + 1 + (child_index - 1) x 1
For 2nd child: 0x0002 + 1 + (1 x 1) = 0x0004
For 3rd child: 0x0002 + 1 + (2 x 1) = 0x0005

Floor 1, Zone B Router (second router child of floor router):

Address = Parent + 1 + (router_index x Cskip(2))
Address = 0x0001 + 1 + (1 x 9) = 0x000B

(router_index starts at 0 for first router child)
So Zone A router (index 0): 0x0001 + 1 + (0x9) = 0x0002
Zone B router (index 1): 0x0001 + 1 + (1x9) = 0x000B
Zone C router (index 2): 0x0001 + 1 + (2x9) = 0x0014

Step 3: Complete Floor 1 Address Map

Floor 1 Router: 0x0001
|
+-- Zone A Router: 0x0002 [range 0x0002-0x000A]
|  +-- Sensor 1: 0x0003
|  +-- Sensor 2: 0x0004
|  +-- Sensor 3: 0x0005
|  +-- Light 1: 0x0006
|  +-- Light 2: 0x0007
|
+-- Zone B Router: 0x000B [range 0x000B-0x0013]
|  +-- Sensor 4: 0x000C
|  +-- Sensor 5: 0x000D
|  +-- HVAC 1: 0x000E
|  +-- HVAC 2: 0x000F
|
+-- Zone C Router: 0x0014 [range 0x0014-0x001C]
   +-- Sensor 6: 0x0015
   +-- Sensor 7: 0x0016
   +-- Access Point: 0x0017

Step 4: Floor 2 Router Addressing

Floor 2 Router (second child of coordinator):

Address = 0x0000 + 1 + (1 x Cskip(1))
Address = 0x0000 + 1 + (1 x 73)
Address = 0x004A

Floor 2 address range: 0x004A to 0x0092 (73 addresses)

Step 5: Verification - Total Address Space

With 10 floors:

Floor 1: 0x0001 - 0x0049 (73 addresses)
Floor 2: 0x004A - 0x0092 (73 addresses)
Floor 3: 0x0093 - 0x00DB (73 addresses)
...
Floor 10: 0x0289 - 0x02D1 (73 addresses)

Total addresses needed: 10 x 73 = 730 addresses
Fits in 16-bit address space? YES (730 < 65,535)

Benefits of Cskip Addressing:

1. Distributed Allocation: Zone routers assign addresses without contacting coordinator
2. Routing Efficiency: Parent-child relationship encoded in addresses
3. Scalability: Each level operates independently
4. Deterministic: Address assignment is algorithmic, not random

Trade-offs:

1. Address Waste: If Cm=8 but only 3 zones exist, 5 address blocks go unused

   • Zone A uses 8 addresses, wastes 1 (Cskip(2)=9)
   • Total waste per floor: ~30% (if 3 zones use 27 addresses out of 73)

2. Topology Rigidity: Cannot exceed Cm=8 or Rm=3 without reconfiguring entire network

3. Not Optimal for Flat Networks: Wastes addresses if network is actually flat but configured with high Lm

Real-World Configuration Choice:

For this building, better parameters might be:

Lm = 3 (only need 3 levels: coordinator -> floors -> devices)
Cm = 15 (some floors have 10+ devices per zone)
Rm = 10 (allow 10 floor routers instead of 3)

Cskip(2) = 1 (leaf level)
Cskip(1) = 1 + 15x1 = 16
Cskip(0) = 1 + 15x16 = 241

Each floor router gets 16 addresses (enough for typical zones)
10 floors x 16 = 160 addresses total
Much more efficient than 730 addresses!

Key Insight: Cskip configuration directly impacts address space efficiency. Choose Lm, Cm, Rm based on actual network topology, not arbitrary defaults. Overly large Cm or Lm wastes addresses; too small prevents network growth.

Concept Relationships

Quiz Topic	Tests Understanding Of	Connects To	Real-World Application
Addressing Modes	Overhead calculation, frame efficiency	MAC layer, payload budget	Battery life optimization
Cskip Algorithm	Hierarchical addressing, distributed allocation	Tree topologies, address space	Scalable network formation
Superframe Timing	SO/BO parameters, duty cycle math	Power management, beacon mode	Battery-powered sensor design
FFD/RFD Memory	Device architecture, routing vs leaf nodes	Network roles, cost optimization	Deployment planning

Common Pitfalls

1. Forgetting Intra-PAN Compression Saves Bytes

When source and destination are in the same PAN, the destination PAN ID can be omitted from the frame (the PAN ID compression bit in frame control). Forgetting this optimization overstates addressing overhead by 2 bytes — significant for small frame efficiency calculations.

2. Using Reserved Addresses (0x0000 and 0xFFFF) for Regular Devices

Short address 0x0000 is reserved for the PAN coordinator and 0xFFFF is the broadcast address. Assigning either to a regular end device causes routing failures and broadcast storms. Address allocation must reserve these values.

3. Applying Cskip With Wrong Depth Parameter

The Cskip formula uses depth d measured from the coordinator (d=0) to the leaf level (d=Lm). Off-by-one errors in depth indexing cause overlapping address ranges in adjacent tree levels, producing silent address collisions.

4. Not Planning for Address Reuse After Device Departure

Short addresses are not automatically reclaimed when a device leaves the network. Without an address management protocol, address space can be exhausted even with few active devices after repeated join/leave cycles in long-lived deployments.

🏷️ Label the Diagram

💻 Code Challenge

84.9 Summary

This quiz section covered the fundamental aspects of IEEE 802.15.4 addressing and network structure:

Topic	Key Concept	Practical Impact
Addressing Modes	16-bit short vs 64-bit extended	6 vs 18 bytes overhead (12-byte savings)
Tree Addressing (Cskip)	Hierarchical address allocation	Distributed assignment without coordinator
Superframe Timing	SO/BO determine active duty cycle	25% active = 3-5 year battery life
FFD vs RFD	Routing capability vs simplicity	10x cost/power savings for RFDs

84.10 See Also

• 802.15.4 Fundamentals - Core concepts review
• Power and Performance Quiz - Battery life calculations
• Device Types and Security Quiz - FFD/RFD deep dive
• 802.15.4 Topic Review - Quick reference guide
• Quiz Bank Part 1 Overview - Complete quiz navigation

84.10.1 Key Formulas

Superframe Timing:

• Beacon Interval (BI) = aBaseSuperframeDuration x 2^BO
• Superframe Duration (SD) = aBaseSuperframeDuration x 2^SO
• Duty Cycle = SD / BI = 2^(SO-BO)

Addressing Overhead:

• Short addressing: 6 bytes (2+2+2 PAN)
• Extended addressing: 18 bytes (8+8+2 PAN)
• Mixed mode: 12 bytes (8+2+2 PAN)

84.11 What’s Next

Chapter	Focus
Power and Performance Calculations	Battery life, GTS allocation, and variant selection questions
Device Types and Security	FFD/RFD details, AES-128 encryption, and channel hopping
Quiz Bank Part 1 Overview	Return to main quiz navigation and topic selection