Skip to content
This repository has been archived by the owner on Aug 25, 2020. It is now read-only.

Design Document Wireless Testbeds

Jump to bottom
danbim edited this page Jul 20, 2011 · 1 revision

A wireless testbed is a testbed that consists of both wired and at least one wireless sensor node. This scenario arises a number of issues that require different implementations of the APIs compared to the purely wired testbed setup.

Multi-hop Over The Air Programming (MOTAP) functionality

Please note: This document does not assume that the reader can fully understand it if he was not present during the design of it. It is more of a mnemonic for the authors.

For reprogramming of wireless sensor nodes in a testbed you need a MOTAP protocol that is supported by both the backend and the sensor nodes in it. This document assumes that there is such a protocol as well as an implementation for both the backend and for the sensor node counterpart. Therefore, this document describes how an API call to the flashProgram method of the WSN API is distributed over the testbed-runtime internal overlay network in order to time-efficiently reprogram all requested nodes.

Assumptions

  • The portal server knows which of the nodes in the testbed are wireless and which are wired.
  • All wired nodes support iSerAerial functionality (if they don't this can be handled by reprogramming this very node before starting to MOTAP the wireless nodes through the wired one).
  • All wireless nodes to be flashed support the MOTAP protocol.

Portal Pseudo Code (flashPrograms())

Input:  (nodes, program) where nodes is a Set<NodeURN> that contains the URNs of the
        nodes that should be reprogrammed and program is the program to be used
Output: results where result is a Map<NodeURN, Result> that maps the URN of a node to
        the result of flashing it, indicating success or failure

wirelessNodes = {nodeURN in nodes : nodeURN is a wireless node}
wiredNodes = {nodeURN in nodes : nodeURN is a wired node}

wirelessResults = wirelessNodes[0].flashWireless(wirelessNodes, program, ø)
wiredResults = parallelExecution(wiredNode in wiredNodes) {
    flashWired(wiredNode)
}

results = wirelessResults.union(wiredResults)

Gateway Pseudo Code (flashWireless())

Input:  (nodes, program, previousResults, useMotap) where nodes is a Set<NodeURN>
        that contains the URNs of the nodes that should be reprogrammed, program is the
        program to be used and useMotap is a boolean parameter that defines if wireless or
        wired programming algorithm should be used
Output: results where result is a Map<NodeURN, Result> that maps the URN of a node
        to the result of flashing it, indicating success or failure

presentNodes = presenceDetect()
participatingDevices = nodes.intersection(presentNodes)
participatingResults = motap(participatingDevices, program)
nodes = nodes \ participatingDevices
results = previousResults.union(participatingResults)

if (nodes != ø)
    results = nodes[0].flash(nodes, program, results, useMotap)
fi

Properties

  • If a wireless node is not successfully reprogrammed at the first try (i.e. a presence detect succeeded at one of the gateways and an error occurs during the subsequent execution of the programming algorithm) the algorithm does not retry to reprogram it from a different gateway node. Reason: This would lead to a very big worst case runtime if every gateway would retry.
  • Flashing a mixed set of both wireless and wired nodes results in a two-phase execution in which at first the wireless nodes are flashed and subsequently the wired nodes are flashed.
Clone this wiki locally