LoRaWAN and TTN

Learning Goals 5 min

Plain LoRa is two modules talking. LoRaWAN is the protocol that lets thousands of devices share a public network. The Things Network (TTN) is a free, community-run global LoRaWAN with gateways covering ~200 countries. By the end of this lesson you will:

1. Explain the LoRaWAN three-layer architecture: end-device → gateway → network server.
2. Register a device on TTN and pick its activation method (OTAA vs ABP).
3. Decode an uplink message in TTN's console and route it to a webhook or MQTT integration.

Warm-Up 10 min

No hardware required — today is conceptual + a free TTN account.

Check coverage

Visit ttnmapper.org. Search your area. If you see gateway dots, you have free LoRaWAN coverage. If not, you'd need to deploy your own gateway (a costly extra) or use a different network like Helium / Senet.

New Concept · The LoRaWAN architecture 25 min

Three layers

1. End-device: your battery-powered Arduino + LoRa module. Sends "uplinks" (data going up) periodically. Sleeps in between.
2. Gateway: a more capable LoRa receiver, often roof-mounted, with internet connectivity. Forwards every packet it hears to a network server. Doesn't belong to any device — "public" gateway can hear any device near it.
3. Network server: a cloud service that decrypts and routes messages. TTN is the most popular free one.

Plus the "application": your code or service that consumes the data. Could be a webhook, an MQTT integration, a Node-RED flow, an HTTP endpoint.

Flow of an uplink

1. End-device packages 10 bytes of sensor data, encrypts with its session key, sends as LoRa packet.
2. Every gateway in range hears it. Each one forwards to TTN, tagged with its own location + RSSI.
3. TTN deduplicates (multiple gateways may have heard the same packet), decrypts using the device's key.
4. TTN routes the decrypted payload to the configured destination — your webhook, MQTT broker, etc.
5. Your application receives the payload + metadata (which gateways, when, how strong).

Activation: OTAA vs ABP

Device classes

For battery-powered sensors, always Class A.

Setting up a device on TTN

1. Create a free TTN account at thethingsnetwork.org.
2. Console → Applications → Create application. Name it.
3. Add an End Device → Manually (or pick a board if it's in the catalogue).
4. Pick frequency plan (EU868 / US915 / AS923 etc.) — match your region.
5. LoRaWAN version: latest (1.0.3 or 1.1).
6. Activation mode: OTAA.
7. Note the auto-generated DevEUI, AppEUI (or JoinEUI), AppKey. Copy these into your sketch.

Sketch — using MCCI LMIC library

The most popular Arduino LoRaWAN library. Install via Library Manager ("MCCI LoRaWAN LMIC library").

Configuration is more involved than plain LoRa — you need to set the DevEUI / AppEUI / AppKey, schedule transmissions (respecting duty cycle), handle the join, and parse downlinks. Adafruit and TTN publish example sketches; start from those.

// Skeleton — full LMIC sketches are 200+ lines; this is the shape.
#include <lmic.h>
#include <hal/hal.h>

static const u1_t DEVEUI[8] = { /* from TTN, LSB order */ };
static const u1_t APPEUI[8] = { /* from TTN, LSB order */ };
static const u1_t APPKEY[16] = { /* from TTN, MSB order */ };

void os_getDevEui(u1_t* buf) { memcpy_P(buf, DEVEUI, 8); }
void os_getArtEui(u1_t* buf) { memcpy_P(buf, APPEUI, 8); }
void os_getDevKey(u1_t* buf) { memcpy_P(buf, APPKEY, 16); }

void setup() {
  os_init();
  LMIC_reset();
  LMIC_startJoining();
}

void loop() {
  os_runloop_once();
}

Once joined, you'd call LMIC_setTxData2(port, data, len, confirmed) to queue an uplink. The library handles channel hopping, duty-cycle enforcement, and downlink receipt.

Worked Example · Register and send your first uplink 20 min

Step 1 — set up the TTN application

Follow the steps in §3 above. Get DevEUI / AppEUI / AppKey.

Step 2 — wire and program

Same RFM95 wiring as L04-18. Use the "ttn-otaa-feather-us915-dht22" example (or the EU868 version) from the LMIC library and replace the keys with yours.

Step 3 — observe the join

Serial Monitor shows "Joining..." → "Joined!" within a minute (assuming a gateway is in range).

Step 4 — observe the first uplink

In TTN console → your application → your device → Live data. You'll see incoming packets, with the gateway that received them, RSSI, decoded bytes.

Step 5 — add an integration

TTN → Application → Integrations → MQTT or Webhooks. Configure to forward every uplink to your service. Now your TTN packets land in MQTT (Home Assistant!) or a custom HTTPS endpoint.

Step 6 — send a downlink

From TTN console → your device → Messaging → Downlink. Enter a hex payload. Send. Your device receives on its next Rx window.

Basic 5 min

Challenge 1 5 min

DevEUI   70B3D57ED005A1B2
JoinEUI  0000000000000001
AppKey   2B7E151628AED2A6ABF7158809CF4F3C

Challenge 2 5 min

It works if every answer shows its working, with units.

Challenge 3 · Check a tracker plan before you build it 10 min

A teammate plans a TTN pet tracker. It sends a GPS fix every 10 minutes. It must last 6 months. Their plan uses SF10 (~500 ms per packet).

1. Count the packets per day. Does SF10 fit TTN's 30 s a day? If not, how often could it send at SF10?
2. At SF7 (~50 ms per packet), does a fix every 10 minutes fit?
3. Each fix-and-send uses 40 µAh. Sleep is 5 µA. Work out the charge per day.
4. Pick the smallest battery that lasts 183 days: 500, 1,000, 1,200 or 2,000 mAh.

It works if you show the original plan breaks the airtime rule. Name a battery and the days it lasts.

Recap 5 min

LoRaWAN = LoRa physical + a network layer with gateways + a network server. TTN is the free public option. Register a device on TTN, copy keys into your sketch, use LMIC library, see packets in the console. Tomorrow we leave radio and go industrial: Modbus on RS-485.

LoRaWAN

Network protocol on top of LoRa. Standardised by the LoRa Alliance. Adds encryption, addressing, gateway support.

End-device

Your sensor / actuator. Talks LoRa to gateways.

Gateway

Receiver with internet. Forwards packets to a network server. Doesn't process the contents.

Network server

Cloud service that authenticates devices, decrypts payloads, routes to applications. TTN is the most popular free one.

OTAA / ABP

Activation methods. OTAA = join procedure with key derivation. ABP = static keys.

DevEUI / AppEUI / AppKey

Identifiers and the root key used during OTAA join.

Class A / B / C

Power-vs-listening tradeoffs. Class A = always-sleep, briefly-listen; Class C = always listening.

Uplink / downlink

Device → server / server → device. Uplinks are frequent; downlinks are rare and limited.

LMIC library

The standard Arduino LoRaWAN library. Handles channels, duty cycle, joins.

TTN integrations

Outputs: MQTT, webhooks, Node-RED. Forward uplinks to your service.

Extra Mission 5 min

Part 1 — Plan a real LoRaWAN deployment

Pick a sensor you would put on TTN — a bike tracker, a garden rain gauge, a letterbox alert. On paper, plan it.

Your plan must include:

• What it sends, and the payload laid out byte by byte.
• The SF, and how often it sends, checked against TTN's 30 s a day.
• OTAA or ABP, with a reason.
• A battery estimate, done like Challenge 3.
• The gateways near you that could hear it (look on ttnmapper.org).

Part 2 — Make it

Make a free TTN account and register your device. Put its keys into the LMIC sketch in the right byte order, and add your payload-packing code. If you have LoRa hardware and a gateway in range, send a real uplink.

Bring back next class: the sketch, and a screenshot of your TTN device page or its Live data. For ARD-L04-20, bring an RS-485 module (MAX485) if you have one.