SWP14
Below is a list of topics proposed for SWP 2014. There are 3 categories of projects:
- System
- Network
- Application
Project Category: System
Brief explanation: The goal of dynamic linking support in RIOT is two-fold, (i) enable loading and unloading of modules/functionalities at runtime, and (ii) implement the first phase of an approach towards enabling (automatic) software updates.
Expected results: concept and prototype implementation of dynamic linker.
Knowledge Prerequisite: C, gcc, git, notions of how compiler and linker work.
Any of these are optional but not all of them.
Project Category: System
Brief explanation: RIOT can already run as a process in Linux via the native port and several RIOT instances can be networked on the same Linux machine via dedicated tools (nativenet and desvirt). However, RIOT support within ns3 is expected to enable the community to simulate larger networks of RIOT instances and finer grained network characteristics -- before deployment of the exact same code base on real hardware.
Expected results: multiple, networked instances of RIOT can be simulated within ns3.
Knowledge Prerequisite: C, C++, Python, git, ns3.
Any of these are optional but not all of them.
Project Category: Network
Brief explanation: Security is essential to protect the communication between IoT devices. Datagram Transport Layer Security (DTLS) RFC 6347 is the mandatory standard to provide security in this context. There are several implementation challenges of DTLS on embedded systems that one needs to keep in mind.
Expected results: Transport Layer Security can be used over the available UDP implementation in RIOT.
Knowledge Prerequisite: C, git, COAP, some notions of cryptography
Any of these are optional but not all of them.
Project Category: Application
Brief explanation: Python is used for simple object oriented programming. The goal of this project is two-fold (i) to allow easier application programming in RIOT and (ii) in a second optional phase, to provide a generic way to access sensor data through Python scripts.
Expected results: implement the C API (and an interpreter) of Python to allow the standard libraries of Python and Python scripts to run on RIOT.
Knowledge Prerequisite: C, Python, git, some notions of programming theory, and embedded programming.
Project Category: Application
Brief explanation: eLua is a bare-metal embedded distribution of the Lua programming language. It sports a minimal MCU specific layer on top of which embedded devices can be programmed in Lua. This project aims to create a generic port of eLua to RIOT so that eLua's extensive Lua interpreter, libraries and applications can be run on any RIOT powered device with enough ressources.
Expected results: eLua runs as an application on top of RIOT.
Knowledge Prerequisite: C, Lua, git
Any of these are optional but not all of them.
Project Category: System
Brief explanation: RIOT supports several 32bit ARM Cortex platforms, such as M3 and M4, but not yet platforms based on ARM Cortex A8 such as the BeagleBone. The goal of the project is to support this platform.
Expected results: RIOT kernel runs on BeagleBone.
Knowledge Prerequisite: C, Assembler, git
Project Category: System
Brief explanation: RIOT runs on 16bit platforms (e.g. TI MSP430) and on 32bit platforms (e.g. ARM Cortex) but not yet on 8 bit platforms such as Atmel ATmega328 which powers popular tiny boards including Arduino Uno. This project aims at providing support for such boards.
Expected results: RIOT kernel runs on Arduino Uno.
Knowledge Prerequisite: C, Assembler, git.
Project Category: Application
Brief explanation: Cloud platforms such as Thingspeak provide not only a unified access to several IoT platforms but also ease the development of IoT applications. This project aims at implementing a thingspeak client for RIOT.
Expected results: Library that runs on RIOT to communicate with the open application platform thingspeak. Example RIOT application integrated into thingspeak.
Knowledge Prerequisite: C, HTTP, git
Project Category: System
Brief explanation: RPython is a subset of the Python language that can be compiled to C. The goal of this project is two-fold (i) to use PyPy to compile RPython to C which can be compiled along with RIOT for embedded devices, and (ii) to develop an RPython module to interface with RIOT.
Expected results: Implementation of an RPython module to allow the development of RPython applications that interface with RIOT. Integration of PyPy for embedded devices.
Knowledge Prerequisite: C, Python, git, some notions of programming theory, and embedded programming.
Project Category: System
Brief explanation: Betty is a programmable smart remote control with advance RF hardware (CC1100) at a Sub-GHz frequency which very attractive because very cheap. The main challenge here is its very limited memory.
Expected results: Port of RIOT for the Betty remote control and network compatibility to existing testbed network (based on MSB-A2 which uses the same radio chip).
Knowledge Prerequisite: C, git, some hardware hacking skills might help
Project Category: System
Brief explanation: BLE (Bluetooth Low Energy) is a key element of the Internet of Things, on the wider consumer electronics side (devices like smartphone, Tablets etc.). Newer embedded hardware such as Nordic nRF BLE provides this network functionality via a cheap ARM M0 SoC. The main challenge here is its very limited memory, and the BLE spec implementation.
Expected results: Port of RIOT for the Nordic nRF BLE. Two RIOT-based BLE boards exchanging messages over Bluetooth and the UDP/IP/6LoWPAN stack already provided by RIOT.
Knowledge Prerequisite: C, git, basic computer network knowledge (wireless link layer)
Project Category: Application (Application Layer)
Brief explanation: CBOR stands for Concise Binary Object representation and is an alternative for JSON for constrained devices using a binary representation. The key challenge of this implementation is finding a representation of mixed objects in C while keeping a low memory footprint
Expected results: A complete CBOR implementation for RIOT tested with at least one existing implementation
Knowledge Prerequisite: C, git, knowlege of JSON is a plus
Project Category: System
Brief explanation: For portable devices drivers and application development a consistent hardware abstraction for MCU peripherals (ADC, SPI, ...) is needed. RIOT's current peripheral driver should be advanced and implemented for different platforms. The key challenge here is to have the same interface on (very) heterogeneous platforms.
Expected results: Definition of a consistent interface and it's implementation on a minimum of two different platforms (e.g. MSP430, ARM7, ARM Cortex-M)
Knowledge Prerequisite: C, git, microcontroller architecture
Project Category: System
Brief explanation: Profiling tools can be used to analyze energy consumption at runtime, which is very useful to evaluate in detail the energy efficiency of the system. The key challenge here is sampling and process data at high rate without interfering with normal operation.
Expected results: Analyze at runtime the amount of energy consumed by whom (which function?) at which time.
Knowledge Prerequisite: C, git, software profiling, understanding of electrotechnical processes
Project Category: Network
Brief explanation: Scheduling strategies for IPv6 over Time-slotted and Channel Hopping 6Tisch are an interesting approaches to provide delay guarantees while keeping energy consumption down. However, TDMA has high requirements to the time synchronization of the nodes.
Expected results: Implementation of a 6TiSCH transmission scheduling algorithm in RIOT (distributed or centralized)
Knowledge Prerequisite: C, git, 6LoWPAN and IEEE802.15.4(e), some elements of graph theory
Project Category: Application
Brief explanation: RIOT TV is a visualization tool for RIOT based on node.js, but so far rather static. the goal of this project is to collect the required data for visualization in a non-invasive manner and visualize a priori unknown topologies.
Expected results: Visualize different types of RIOT networks without changes to the operating system in flexible way
Knowledge Prerequisite: C, git, radio sniffers, node.js, graph visualization
Project Category: Application
Brief explanation: POSIX compliant shell are very useful for a variety of tasks, including easy porting to RIOT of scripts that were developed for Linux.
Expected results: port dash (or busybox), a lightweight POSIX compliant shell, to RIOT.
Knowledge Prerequisite: C, git, POSIX
Project Category: Application
Brief explanation: HTTP/TCP is considered too power and memory hungry for constrained IoT devices to provide . Recently, an alternative has been proposed with CoAP (running over UDP), which provides a light-weight request-response protocol designed for IoT devices.
Expected results: implementation of a CoAP server in RIOT and interoperation with CoAP client in Contiki
Knowledge Prerequisite: C, git, basic computer network knowledge, 6LoWPAN, and Contiki would be a plus
Project Category: System
Brief explanation: Go is programming language that targets multicore and networked machines, based on a specific type system that enables flexible and modular program construction.
Expected results: you can link a simple Go application with RIOT.
Knowledge Prerequisite: C, Go, git
Project Category: Network
Brief explanation: Spontaneous wireless network testbeds such as IoT-Labs have been designed to be open to the public and accessible through web interfaces. Such interfaces allow anyone to schedule, carry out and analyse experiments on various hardware, falshable remotely with configurable firmware based on RIOT for instance.
Expected results: Compare the performance of several routing protocols including RPL, AODVv2, OLSRv2 in terms of control traffic overhead, packet delivery ratio etc. on topologies of hundreds of nodes on IoT-Labs and/or DES testbed.
Knowledge Prerequisite: C, git, basic knowledge of wireless networks and ad hoc routing protocols
Project Category: Network
Brief explanation: P2P-RPL (RFC 6997) is an extension of the standard routing protocol RPL, providing on-demand route discovery.
Expected results: P2P-RPL in RIOT. Demonstrate the functionality of reactive, sensor-to-sensor path discovery without support of the basic RPL tree. Demonstration should happen both on a virtual network (with nativenet) on appropriate toy topologies, and on an open testbed such as IoT-Labs or DES testbed.
Knowledge Prerequisite: C, git, basic knowledge of wireless networks and ad hoc routing protocols
Project Category: Network, System
Brief explanation: Sometimes it is helpful to have a virtual network interface - even on a contrained platform. Transparent tunnels are an obvious example. Somewhat more "interesting" uses exist as well: OLSR for example uses a virtual network interface as a default route to trigger lookups in their Linux implementation (Oleg might explain this in more detail).
Expected results: Virtual network driver and example application. The choice of a sensible application is up to you!
Knowledge Prerequisite: C, git, knowledge of networks and protocols
Project Category: Network, Application, System
Brief explanation: In order for an IoT to connect to the Internet a Border Gateway Router is required. It translates between the IoT network protocol and the regular Internet protocol. RIOT already has a Border Gateway Router, but it is in an unknown state. Make it shine!
Expected Results: An application that bridges between the IoT network and the Border Gateway Router and the Border Gateway Router itself. The application should be demonstrated to run on at least one of physical RIOT platforms and the native platform. The border gateway router should run on at least Linux and one other POSIX platform with Valgrind without errors.
Knowledge Prerequisite: C, git, knowledge of networks, especially IPv6 and 6LoWPAN, and POSIX system programming
Project Category: Network, System
Brief explanation: To facilitate more natural communication between a RIOT node and regular computer, a driver for RIOT to provide the UART as a regular network interface would be nifty. This project will ideally be working in close collaboration with the Border Gateway Router project for mutual benefits.
Expected Results: A network interface implementation that uses a USART interface as a network interface. The details are up to you, there is room for creativity with regard to getting most out of the USART (Hauke might shed some light on this). Additionally a simple gateway between the USART and nativenet using a tap interface should be implemented. Demonstrate a working mixed native / physical network.
Knowledge Prerequisite: C, git, knowledge of networks, protocols and POSIX system programming