Gateway Concepts

Internet to WSN

The situation. A user on the Internet wants something from the sensor network: the latest readings, or a new task.

The problems, and how a gateway solves them.

• Which gateway to ask. The user must know an Internet address for the WSN. The gateway presents one: a web page, a web service, or a named endpoint.
• Expressing the request. The user's request (a web request for average temperature, north-west quarter) must be turned into the WSN's own terms: an interest, a query or a task, sent into the field. The gateway is therefore an application-level gateway: it understands the meaning of requests, not only their packets.
• Waiting for sleeping nodes. A request may take a long time to be answered inside the WSN. The gateway can answer from its cache of recent readings, and can collect one answer for many users, so the nodes are asked once.
• Protecting the field. The gateway can refuse, rate-limit or authenticate requests, so that a busy website does not drain the batteries of a forest.

WSN tunnelling

The situation. Two sensor networks are far apart, a sensor field on each bank of a river, or two buildings of one campus, and should behave as one network. No radio link joins them.

The idea. Each island has a gateway on the Internet. When a packet in one island is addressed to something in the other, its gateway encapsulates the whole WSN packet inside an Internet packet and sends it to the other gateway, which unwraps it and injects it into its own island. The Internet is used as a long virtual link, a tunnel. To the WSN protocols the two islands look like one network with one long hop.

The humblest gateway: a base station mote on a serial cable

In a laboratory, and in the practical, the gateway is a base station mote connected to a PC by a USB or serial cable. The mote listens to the radio and passes what it hears to the PC; the PC runs the program that stores, displays or forwards the data.

TinyOS ships this as an application. Its own source comment says it plainly: "BaseStationP bridges packets between a serial channel and the radio." Packets from the radio are passed to the serial port; packets from the PC are sent out over the radio. Messages going from serial to radio are tagged with the group identity compiled into the base station, and radio messages are filtered by that same group, so a base station hears only its own network.

How the bytes cross the cable

A serial line carries a stream of bytes, with nothing to mark where one packet ends and the next begins. TinyOS's serial stack, specified in TEP 113, solves this in three levels: encoding, framing and a protocol level with acknowledgements and a CRC. Its framing uses the same encoding as the HDLC protocol:

• 0x7e is reserved as the frame delimiter: it marks the start and end of every packet.
• 0x7d is reserved as the escape byte.
• If the data itself contains 0x7e or 0x7d, the sender sends 0x7d followed by the byte XORed with 0x20. TEP 113's example: "0x7e becomes 0x7d 0x5e".
• The receiver, on seeing 0x7d, drops it and XORs the next byte with 0x20 to recover the original.

A CRC (cyclic redundancy check) at the protocol level lets the receiver detect a packet damaged on the cable.

Worked example: framing a packet

The program frames a five-byte payload that happens to contain both reserved bytes, then decodes it again. (The CRC is left out so that the framing can be seen on its own.)

# HDLC-style framing as TinyOS's serial stack uses it (TEP 113):
# 0x7e marks frame boundaries, 0x7d escapes, an escaped byte is XORed with 0x20.
FLAG, ESC = 0x7E, 0x7D

def frame(payload):
    out = [FLAG]
    for b in payload:
        if b in (FLAG, ESC):
            out += [ESC, b ^ 0x20]
        else:
            out.append(b)
    return out + [FLAG]

def unframe(stream):
    body, escaped = [], False
    for b in stream[1:-1]:                  # drop the two delimiters
        if escaped:
            body.append(b ^ 0x20)
            escaped = False
        elif b == ESC:
            escaped = True
        else:
            body.append(b)
    return body

payload = [0x12, 0x7E, 0x34, 0x7D, 0x56]
line = frame(payload)
print("payload:", " ".join("%02x" % b for b in payload))
print("on the wire:", " ".join("%02x" % b for b in line))
print("decoded:", " ".join("%02x" % b for b in unframe(line)))
print("round trip correct:", unframe(line) == payload)

payload: 12 7e 34 7d 56
on the wire: 7e 12 7d 5e 34 7d 5d 56 7e
decoded: 12 7e 34 7d 56
round trip correct: True

What happened to the two reserved bytes. 0x7e in the data became the pair 0x7d 0x5e (0x7e XOR 0x20 is 0x5e), exactly TEP 113's example, and 0x7d became 0x7d 0x5d. Only the two real delimiters, at the ends, appear as bare 0x7e, so the receiver always knows where a frame starts and stops. The frame is two bytes longer for the delimiters and two more for the escapes: framing costs a little size for certainty.

A real gateway: Great Duck Island

The deployment of [Applications of Wireless Sensor Networks] shows the full chain. Each patch of motes had a gateway node; a longer radio link, the transit network, carried data from the gateway to a base station with a database and a wide-area connection; and remote users read a replica of that database over the Internet. Every layer kept some persistent storage, because a disconnection could happen at any level. That is Internet-to-WSN communication done through a cache, which is how most real systems do it.

Distinctions

What it does not mean

A gateway is not only a router. A router forwards packets of one protocol; a gateway translates between protocols and between ways of addressing, often at the level of meaning.

Internet-to-WSN does not mean a TCP connection to each node. The gateway answers for the network, from a cache or by collecting one answer for many users.

Tunnelling does not make the Internet part of the WSN. The Internet only carries the WSN's packets, wrapped, between two gateways.

The serial escape is not encryption. It only keeps the reserved bytes from being mistaken for delimiters.

Quick revision

• Gateway: joins the WSN to another network; needed for different protocols, different addressing, different availability, and a boundary for security and caching.
• WSN to Internet: node reports data-centrically to the gateway; gateway maps to Internet destinations and translates.
• Internet to WSN: gateway gives the WSN an Internet address, translates requests into queries or interests (an application-level gateway), caches answers, protects the field.
• WSN tunnelling: gateways encapsulate WSN packets in Internet packets to join two WSN islands.
• Base station mote: TinyOS BaseStation "bridges packets between a serial channel and the radio", filtered by group identity.
• TEP 113 framing: 0x7e delimiter, 0x7d escape, escaped byte XOR 0x20 (0x7e becomes 0x7d 0x5e), plus a CRC.

Test yourself

1. Why does a WSN need a gateway to reach the Internet? Because the two sides differ in protocols (low-power radio and WSN routing against IP), addressing (data-centric names against host addresses) and availability (sleeping nodes against always-on hosts), and because security, access control and caching belong at the boundary.

2. Explain Internet-to-WSN communication and the problems a gateway solves in it. An Internet user requests data or tasks the WSN. The gateway gives the WSN an Internet address, translates the request into the WSN's own query or interest, answers from a cache or gathers one answer for many users because nodes sleep, and protects the field by authenticating and rate-limiting requests.

3. What is WSN tunnelling? Joining two separate WSN islands through the Internet: each island's gateway encapsulates WSN packets bound for the other island in Internet packets, and the other gateway unwraps and injects them, so the Internet acts as one long virtual link.

4. How does TinyOS frame a packet on a serial line, and how is a data byte of 0x7e sent? With HDLC-style framing: 0x7e marks the start and end of each frame and 0x7d is the escape byte. A data byte of 0x7e is sent as 0x7d followed by 0x7e XOR 0x20, which is 0x5e.

5. What does the TinyOS BaseStation application do? It bridges packets between the radio and the serial port: radio packets of its group are passed to the PC, and packets from the PC are sent over the radio, tagged with the base station's group identity.