Industry Insights

Massive LPWAN access without scheduling: code-domain SIMS

Why LPWAN capacity is a separation problem, how quasi-orthogonal codebooks separate asynchronous users, and how many devices actually fit.

Ask why an LPWAN gateway is full and the answer is rarely "the radio is too slow". It is usually that the network ran out of ways to keep devices apart: channels are exhausted, time slots collide, and the receiver cannot separate two packets that arrive at once. Capacity in these networks is a separation problem, not a throughput problem.

A framework published by our R&D team with Sun Yat-sen University takes the separation problem into the code domain: every device is assigned its own quasi-orthogonal spreading codebook, transmissions are allowed to overlap in time and frequency, and the receiver separates them by correlation. The paper is arXiv:2511.20364; this article works through what the claim means for capacity planning, and what the numbers say about how many devices fit.

Coherence falling as 1/sqrt(N): 0.088 at N=128 down to 0.016 at N=4096

How today's LPWANs separate users

Technology

Access scheme

Separation mechanism

Scalability

Receiver complexity

LoRa

TDMA / FDMA

Spreading factor plus channel

Moderate

Low (chirp correlation)

Sigfox

ALOHA

Randomised frequency and time diversity

Low to moderate

Very low (energy detection)

NB-IoT

Scheduled TDMA / FDMA

Centralised allocation

Limited

Medium to high

Code-domain (this framework)

Code division

Quasi-orthogonal cyclic codebooks

High

Low, O(N_SF log N_SF) per user

Three properties of that last row matter. Separation is complete in the code domain, so the network does not need a scheduler allocating slots; the codebooks can be derived from an equipment serial number at join time, so provisioning is a database operation rather than a radio-planning exercise; and detection stays cheap because each user's codebook is circulant, so correlation is an FFT.

The trade is explicitly acknowledged in the paper: LoRa's time-frequency allocation is simple and well understood, and code-division access buys concurrency by accepting residual interference that must be bounded rather than eliminated.

What "quasi-orthogonal" buys

Two codewords from the same family are never perfectly orthogonal. What the paper proves is that the cross-correlation between them concentrates: the probability that it exceeds a threshold ε decays exponentially in the product of the number of subcarriers K and the sequence length N_SF.

The coherence of the code family sets how fast that happens. By the Welch bound, for M unit-norm sequences of length N, the minimum achievable maximum cross-correlation is approximately μ ≈ 1/√N, and families such as m-sequences, Gold codes and Zadoff–Chu sequences get close to it. So:

Sequence length N

Coherence μ

What it means

128

0.088

Codebooks are still "loud"; small SF is the weak case

256

0.063

Workable for modest user counts

512

0.044

Interference starts behaving like noise

1,024

0.031

Comfortable separation

2,048

0.022

Larger than most deployments need

4,096

0.016

Asymptotically orthogonal

The formula scales the wrong way for short packets, which is why the paper's simulations show the multi-user penalty concentrated at SF5–8 and essentially gone above SF9. It also means the design knob is the sequence length, not the transmit power: you cannot transmit your way out of a coherence problem.

The tail is the whole story

A bound on the average interference is useless for capacity planning. What an operator needs is the probability that any user in the population is unlucky. The paper supplies it: for a fixed tolerance ε and coherence μ,

η = 2·exp( −K·ε² / (2μ² + (2/3)·μ·ε) )

and the residual multi-user interference is bounded by (M−1)²·(K·N_SF)²·ε² with probability at least 1 − (M−1)·η.

Put numbers in it. With K = 8 subcarriers, a tolerance of ε = 0.1, and 1,000 users, the expected number of users outside tolerance is:

Expected number of users outside the interference tolerance, out of 1,000, against sequence length

N_SF

Expected violators out of 1,000

128

49

256

2.5

512

0.017

1,024

5 × 10⁻⁶

2,048

1 × 10⁻¹¹

4,096

4 × 10⁻²⁰

That table is the design argument in one place. At N_SF = 128 — the length of an SF7 LoRa symbol — a thousand-device cell has dozens of users every cycle whose interference exceeds tolerance, and the network has no scheduler to fall back on. At N_SF = 1,024 (SF10) the same population is safe by six orders of magnitude.

The practical reading: code-domain access does not remove the SF trade, it relocates it. You still pay airtime for spreading — every SF step halves the data rate — but instead of buying range, part of that cost is buying user separation.

Asynchrony: where orthogonal codes break

LPWAN devices are not time-synchronised. Two packets can arrive a symbol or two apart, and a receiver that assumed orthogonal codewords (Walsh–Hadamard, or Zadoff–Chu used as an orthogonal set) sees its orthogonality destroyed by that offset. The paper's point is structural: sequences designed to keep cross-correlation low under time shifts survive this, because a shifted copy is exactly what the family was built to tolerate.

The simulations show it directly: with several symbols of misalignment, per-user BER approaches the single-user lower bound as SF grows, and at SF10–11 the single-user and multi-user curves are almost identical. Increasing the user count from two to four degrades BER gracefully at low SF and barely at all at high SF.

Detection without a cancellation stage

Multi-user detection runs the same FFT machinery per user codebook:

z(m) = IFFT( FFT(q_m)* ⊙ FFT(y) ),   m = 0 … M−1

Cost is O(K·N_SF log N_SF) per user and linear in M, with the M codebooks processed in parallel. There is no successive interference cancellation loop, no joint decoding across users, and no central scheduler in the loop. On an FPGA or GPU that parallelises well; on a gateway CPU it scales linearly, which is a very different curve from joint detection.

What it changes for a deployment

  1. Capacity becomes a code-length decision. Choose N_SF so that the expected violators column is comfortably below one for your device count — that is the whole calculation, and it is arithmetic rather than simulation.
  2. Airtime is shared with range. Larger SF buys sensitivity and separation; that is why the multi-user penalty and the sensitivity penalty both move together.
  3. No scheduling infrastructure. No time-slot map, no channel plan per site, no join-time coordination beyond assigning a codebook identifier.
  4. Gateway CPU matters more than gateway RF. Detection cost is O(K·N_SF log N_SF) per user; plan the gateway around FFT throughput, not just receiver sensitivity.

Where it is the wrong tool

Code-domain access is a poor fit where devices are mains-powered and can be scheduled cheaply (that is NB-IoT's home ground), where payloads are large and continuous, or where the operator already runs a licensed, centrally-planned network. It fits the case LPWAN actually serves: many battery devices, small payloads, sporadic traffic, no infrastructure for scheduling.

The physical-layer mechanics behind this — block transmission, processing gain, and where the 3 dB per SF step comes from — are in the companion piece on block signal processing for LPWAN, and the band-level picture is in our sub-GHz overview. For the hardware side, the product catalogue lists the terminal and module line built on the same CPFSK-with-spreading lineage.

More in Industry Insights