20  Quick Reference Cards

Condensed Cheat Sheets for IoT Development

20.1 Learning Objectives

After completing this chapter, you will be able to:

  • Compare key parameters of MQTT, CoAP, BLE, and LoRaWAN protocols using concise reference tables
  • Apply essential IoT formulas for free-space path loss, link budget, battery life, and ADC resolution
  • Identify correct ESP32 pin assignments for ADC, I2C, SPI, UART, and touch interfaces
  • Use common IoT design patterns for sensor reading, MQTT connection, and deep sleep

These are printable cheat sheets – compact summaries of the most commonly needed IoT information, like protocol parameters, pin assignments, and formulas. They are designed to sit next to your computer while you work, saving you from flipping back through long chapters to find a specific number or setting. If you have ever used a keyboard shortcut reference card, these serve the same purpose for IoT development.

In 60 Seconds

Print-ready cheat sheets covering MQTT (QoS levels, topic structure, wildcards), CoAP (message types, methods, options), BLE (GATT structure, advertising), Zigbee (network roles, profiles), LoRaWAN (classes, spreading factors), ESP32 pin-outs, common formulas (link budget, battery life, data rates), and HTTP status codes. Designed for quick reference during development or lab work.

Key Concepts
  • Quick Reference Card: Compact summary of a technical concept including definition, key properties, use cases, and critical parameters — designed for rapid recall, not initial learning
  • Protocol Summary Card: Compact comparison of IoT protocol properties (range, data rate, power, latency, cost) enabling quick selection for deployment scenarios
  • Formula Reference: Quick-access collection of key IoT calculation formulas (latency budget, link budget, bandwidth savings, battery life) with units and typical values
  • Decision Tree Quick Reference: Simplified flowchart for common IoT design decisions (protocol selection, edge vs. cloud) that can be applied in the field without full reference materials
  • Cheat Sheet: Informal quick reference optimized for exam or interview preparation, covering high-frequency concepts and their distinguishing characteristics
  • Spaced Recall: Using reference cards as prompts to practice retrieving information from memory before consulting the answer, reinforcing retention
  • Worked Example Card: Quick reference combining formula with a concrete numerical example to show how theoretical relationships apply to realistic IoT scenarios
  • Comparison Matrix: Reference format showing multiple options (protocols, architectures, hardware) across consistent criteria dimensions for side-by-side evaluation
Chapter Scope (Avoiding Duplicate Hubs)

This chapter focuses on fast lookup during implementation.

  • Use Code Snippet Library for full runnable examples.
  • Use Troubleshooting Flowchart for fault diagnosis, not static parameter lookup.
  • Use this chapter when you need trusted constants, pin maps, and protocol quick comparisons while building.

20.2 Quick Reference Cards

Print-Ready Reference

These cards are designed to be printed or kept open as quick references during development. Each card fits on a single page.

No-One-Left-Behind Reference Loop
  1. Read the quick card first for baseline values.
  2. Validate one value with a simulator or measurement.
  3. Apply the matching code pattern from the snippet library.
  4. Reinforce with one short challenge in the games hub.

20.3 Protocol Quick Reference

20.3.1 MQTT Cheat Sheet

20.3.2 CoAP Cheat Sheet

20.3.3 BLE Cheat Sheet

20.3.4 LoRaWAN Cheat Sheet

20.4 Interactive Formula Reference

20.4.1 Interactive Calculators

20.5 Formula Cards

Let’s design a LoRaWAN sensor for EU868 using the formulas above. Goal: 5-year battery life on 2× AA batteries (2400 mAh).

Step 1: Choose spreading factor

  • Urban environment, gateway at 500m
  • Free Space Path Loss: \(\text{FSPL} = 20\log_{10}(500) + 20\log_{10}(868 \times 10^6) - 147.55 = 85.5\,\text{dB}\)
  • Link budget: \(P_{rx} = 14\,\text{dBm} + 2\,\text{dBi} + 2\,\text{dBi} - 85.5\,\text{dB} - 10\,\text{dB margin} = -77.5\,\text{dBm}\)
  • SF7 sensitivity is -123 dBm → link margin = \(-123 - (-77.5) = 45.5\,\text{dB}\) → SF7 works comfortably

Step 2: Calculate airtime and duty cycle

  • Payload: 12 bytes, SF7 → airtime ≈ 40 ms
  • EU868 duty cycle: 1% = 36 seconds TX per hour max
  • Messages allowed per hour: \(36\,\text{s} \div 0.04\,\text{s} = 900\) messages/hour max
  • We want 1 message every 10 minutes = 6 messages/hour → well within duty cycle (OK)

Step 3: Battery life calculation \[ \begin{align} \text{Sleep current: } & 1\,\mu\text{A}\\ \text{TX current: } & 30\,\text{mA} \text{ @ 14 dBm}\\ \text{TX time: } & 40\,\text{ms per message}\\ \text{Messages: } & 6/\text{hour} = 144/\text{day} \end{align} \]

Average current: \[ I_{avg} = \frac{1\,\mu\text{A} \times (24 \times 3600 - 144 \times 0.04) + 30\,\text{mA} \times (144 \times 0.04)}{24 \times 3600} = 0.0487\,\text{mA} \]

Battery life: \((2400\,\text{mAh} \times 0.8) \div 0.0487\,\text{mA} = 39,424\,\text{hours} = 1,643\,\text{days} = 4.5\,\text{years}\) (OK)

Key insight: Sleep current dominates! Even though TX is 30 mA vs 1 µA sleep, the device spends 99.93% of time sleeping. Reducing sleep current from 1 µA to 0.5 µA gains 1.25 years; reducing TX power from 14 dBm to 10 dBm (15 mA) only gains 2 months.

20.6 Pin-Out Reference

20.6.1 ESP32 Quick Reference

20.7 Common Patterns

20.7.1 Sensor Reading Pattern

# Pseudo-code for robust sensor reading
def read_sensor_with_retry(sensor, max_retries=3):
    for attempt in range(max_retries):
        try:
            value = sensor.read()
            if is_valid(value):
                return value
        except SensorError:
            time.sleep(0.1 * (2 ** attempt))  # Exponential backoff
    return None  # Or raise exception

# Moving average filter
class MovingAverage:
    def __init__(self, window=10):
        self.window = window
        self.values = []

    def add(self, value):
        self.values.append(value)
        if len(self.values) > self.window:
            self.values.pop(0)
        return sum(self.values) / len(self.values)

20.7.2 MQTT Connection Pattern

# Robust MQTT connection with reconnection
def connect_mqtt(client, broker, port=1883):
    def on_connect(client, userdata, flags, rc):
        if rc == 0:
            client.subscribe("device/+/command")
        else:
            print(f"Connection failed: {rc}")

    def on_disconnect(client, userdata, rc):
        while True:
            try:
                client.reconnect()
                break
            except:
                time.sleep(5)

    client.on_connect = on_connect
    client.on_disconnect = on_disconnect
    client.connect(broker, port, keepalive=60)

20.7.3 Deep Sleep Pattern

# ESP32 deep sleep with wake sources
import machine
import esp32

def enter_deep_sleep(seconds):
    # Configure wake sources
    esp32.wake_on_ext0(pin=machine.Pin(0), level=esp32.WAKEUP_ALL_LOW)

    # Set timer wake
    machine.deepsleep(seconds * 1000)

# Check wake reason
wake_reason = machine.wake_reason()
if wake_reason == machine.PIN_WAKE:
    handle_button_press()
elif wake_reason == machine.TIMER_WAKE:
    send_sensor_data()

20.8 Conversion Tables

Scenario: You need to connect a DHT22 temperature sensor, an I2C OLED display, and monitor battery voltage on an ESP32.

Step 1: Identify Required Interfaces

  • DHT22: 1-wire digital protocol (needs any GPIO)
  • OLED: I2C interface (needs SDA + SCL)
  • Battery voltage: Analog input (needs ADC)

Step 2: Consult Pin-Out Reference

  • I2C (default): SDA=GPIO21, SCL=GPIO22
    • Decision: Use default I2C pins for OLED (no conflicts, easier debugging)
  • ADC (12-bit): GPIO32-39 (ADC1), GPIO0,2,4,12-15,25-27 (ADC2)
    • Note: ADC2 unavailable when Wi-Fi active
    • Decision: Use GPIO34 (ADC1_6) for battery voltage - always available
  • DHT22 data pin: Needs any free GPIO
    • Avoid: GPIO0,2,5,12,15 (strapping pins affect boot)
    • Avoid: GPIO34-39 (input-only, can’t use internal pullup)
    • Decision: Use GPIO4 (safe, not strapping, has pullup capability)

Step 3: Validate No Conflicts

  • GPIO4 (DHT22): Available, not used by I2C or ADC
  • GPIO21/22 (OLED I2C): Default I2C, no conflicts
  • GPIO34 (battery ADC): ADC1, works with Wi-Fi enabled

Step 4: Reference Formulas for ADC

  • From formula card: ADC Resolution = Vref / 2^bits
  • ESP32: 12-bit ADC, 3.3V reference
  • Step size: 3.3V / 4096 = 0.8mV per step
  • For 0-5V battery (using voltage divider): Divider ratio = 5V/3.3V = 1.52
    • Use 10kΩ and 15kΩ resistors: (15kΩ/(10kΩ+15kΩ)) × 5V = 3V at GPIO34

Step 5: Code Pattern from Reference

# From Moving Average Pattern (reference card)
battery_filter = MovingAverage(window=10)

# From Sensor Reading Pattern (reference card)
def read_dht22_with_retry():
    for attempt in range(3):
        try:
            temp, humidity = dht.read()
            if temp > -40 and temp < 80:  # Valid range
                return temp, humidity
        except:
            time.sleep(0.1 * (2 ** attempt))
    return None, None

Result: Complete wiring plan and code skeleton in 5 minutes by referencing the Quick Reference Cards instead of searching through 4 different chapter pages and datasheets.

Time Saved: Without reference cards: 20-30 minutes (find I2C chapter, find ADC chapter, look up strapping pins, search for code patterns). With reference cards: 5 minutes (scan one page, make decisions).

Place these steps in the correct order for effective reference card usage.

Key Takeaway

Keep these reference cards handy during development and lab work. The key numbers (CR2032 = 220mAh, LoRa urban range = 2-5km, BLE range = 10-30m, CoAP header = 4 bytes) and protocol comparison tables enable quick design decisions without searching through full chapters.

Concept Relationships: Quick Reference Design Patterns
  • MQTT QoS Levels -> CoAP Message Types: Both provide reliability tiering. QoS 0/1/2 maps loosely to CoAP NON/CON/ACK patterns.
  • ESP32 Pin Configuration -> Power Budget Calculator: Pin selection affects current draw. ADC2 pins become unavailable during Wi-Fi.
  • LoRaWAN SF Selection -> Battery Life Formulas: Higher spreading factors increase airtime, directly impacting duty cycle limits.

Cross-module connection: Protocol Comparison (CoAP vs MQTT) - Compare protocol trade-offs using the same parameters listed on these cards

20.9 See Also

  • Code Snippet Library — Copy-paste implementation examples for the protocols and patterns shown in these reference cards
  • Simulations Hub — Interactive tools to validate link budget, battery life, and ADC formulas shown here
  • Troubleshooting Flowchart — Diagnostic trees that reference these cards for debugging MQTT, Wi-Fi, and sensor issues
  • Protocol Selector Wizard — Decision tool to choose between MQTT, CoAP, BLE, and LoRaWAN based on your requirements
  • IoT Games Hub — Reinforce quick-recall numbers through short challenge loops

Common Pitfalls

Writing personal reference cards before adequately understanding the underlying concepts embeds misconceptions in a convenient format. Study the full chapter material first, verify understanding through quiz performance, then create reference cards summarizing the correctly understood concepts.

Using reference cards as a crutch during practice problems prevents development of the working memory retrieval needed for on-the-job application. During practice, attempt problems without references first — consult cards only to verify your answer or when genuinely stuck, not before attempting recall.

IoT technology parameters (protocol specs, hardware capabilities, cloud pricing) change frequently. Reference cards created during learning become outdated within 12-24 months. Review and update key reference cards annually, particularly for protocol specifications and hardware performance figures.

20.10 What’s Next

If you want to… Read this
Access code examples for common IoT tasks IoT Code Snippet Library
Test your knowledge against quick reference content Quiz Navigator
Build deeper understanding of referenced concepts Interactive Concept Navigator
Apply reference knowledge in hands-on labs Hands-On Labs Hub