Packages

External libraries and applications. More...

Detailed Description

External libraries and applications.

What are packages? RIOT packages:

Using packages

To add a package to the list of compiled modules you have to add it to the USEPKG macro in your application's Makefile:

USEPKG += <pkg_name>

When the package can be built out-of-source, the source code of external packages is fetched in a global location in:

$(RIOTBASE)/build/pkg/$(PKG_NAME)

When out-of-source build is not possible (for example because the package build system doesn't allow it), the source code is fetched in the build directory of the application under:

$(BINDIR)/pkg/$(PKG_NAME)

In this case, the source and the build directory are the same (currently, this only applies to the micropython package).

Porting an external library

Structure of a package

This module provides porting information for libraries and applications to use with RIOT (to build an external module). If you'd like to add a package to RIOT you need to add a directory with the name of your package to this directory. This directory should contain at least one file:

If your port or the package provide header files, you need to update the INCLUDES variable in the package's Makefile.include:

INCLUDES += -I$(RIOTPKG)/<pkg_name>/include # headers provided by the port
INCLUDES += -I$(PKGDIRBASE)/<pkg_name> # headers provided by the package

Patch files can be included in a patches directory in the package dir. These are applied to the upstream package to make it build with RIOT.

Creating a patch with git

Assuming your upstream library resides in a git repository, you can create the patch files as follows:

Packages outside of RIOTPKG

It can be beneficial to create packages outside of the RIOT tree. For example if one is working on new packages that aren't ready to be committed to upstream or if an application needs its own unique packages. For this, one can use the EXTERNAL_PKG_DIRS make variable. It works similar to the way external modules are handled. In your application's Makefile, in addition to adding the package name to USEPKG as shown above, add the path to a folder that contains your external packages:

EXTERNAL_PKG_DIRS += <PATH_TO_FOLDER_CONTAINING_PACKAGES>

The path is allowed to be relative to the application's directory.

NOTE: The name of an external package must be unique (both in regard to other external packages, as well to native RIOT packages). Additionally, the directory containing the packages must match the package name, e.g. package foomust be located in <PATH_IN_EXTERNAL_PKG_DIRS>/foo.

An example can be found in tests/external_pkg_dirs

RIOT welcomes new and useful packages. If you'd like to share your work, consider contributing.

Modules

 ARM Mbed TLS
 SSL crypto library.
 
 ATWINC15x0 WiFi Module Vendor Driver Package
 ATWINC15x0 WiFi vendor driver from the Arduino WiFi101 library.
 
 Arduino library for SDI-12 communication
 Implements support for the SDI-12 serial communications protocol.
 
 BLAKE2 hashing library
 C library providing BLAKE2b, BLAKE2s, BLAKE2bp, BLAKE2sp.
 
 C25519 cryptographic library
 Curve25519 and Ed25519 for low-memory systems.
 
 Cayenne Low Power Payload (LPP)
 Provides a RIOT support for Cayenne LPP format.
 
 Cifra cryptographic library
 Provides the Cifra cryptographic library.
 
 Color graphics library for embedded systems
 Provides a color graphics library for OLED and LCD displays.
 
 Cross platform fixed point maths library
 Provides a cross platform fixed point maths library to RIOT.
 
 Device driver model for the Decawave Impulse Radio-Ultra Wideband (IR-UWB) transceiver(s)
 Hardware and architecture agnostic platform for IoT Location Based Services (LBS)
 
 Driver implementation for the uwb-core driver for Decawave DW1000 transceiver
 uwb-core driver for Decawave DW1000 transceiver
 
 Driver package for I2C/SPI BME680 sensor
 Provides the Bosch Sensortec's BME680 gas sensor API.
 
 EDHOC-C
 Support for Ephemeral Diffie-Hellman Over COSE (EDHOC)
 
 ESP32 SDK for the ESP32 MCU support
 Vendor SDK without libraries for ESP32 MCU support by Espressif.
 
 ESP8266 RTOS SDK for the ESP8266 MCU support
 Vendor SDK with libraries for ESP8266 MCU support by Espressif.
 
 Elk: a tiny Javascript engine
 Elk is a tiny embeddable JavaScript engine that implements a small but usable subset of ES6.
 
 Embedded Template Library
 Embedded Template Library (etl)
 
 FAT file system
 Provides FAT file system support.
 
 Fake Functions Framework
 Fake Functions Framework (fff)
 
 FlatBuffers
 FlatBuffers: Memory Efficient Serialization Library.
 
 FreeRTOS coreJSON
 JSON parser that strictly enforces the ECMA-404 JSON standard.
 
 GEMM (General Matrix Multiplication) library
 Provides support for GEMM library from Google.
 
 GPS parser library
 Provides a GPS parser library to RIOT.
 
 HACL* High Assurance Cryptographic Library
 Support for HACL* (High Assurance Cryptographic Library)
 
 Hardware independent layer of the Arduino cores
 Hardware independent layer of the Arduino cores.
 
 JSON parser library
 Provides a JSON parser library to RIOT.
 
 JSON parser library
 C library for Bitcoin's base58 encoding.
 
 LZ4 compression library
 LZ4 is a fast compression library.
 
 LibHydrogen cryptographic library
 A lightweight, secure, easy-to-use crypto library suitable for constrained environments.
 
 Lightweight ASN.1 decoding/encoding library
 Lightweight ASN.1 decoding/encoding library.
 
 Lightweight Morse encoder
 Provides slim Morse encoding functionality.
 
 Lightweight compression library
 Provides a lightweight compression library to RIOT.
 
 LittlevGL - Open-Source Embedded GUI Library
 LittlevGL package for RIOT.
 
 LittlevGL Drivers
 Display controller and touchpad driver to can be directly used with LittlevGL.
 
 LoRa Basics
 LoRa Basics Modem.
 
 Lora Serialization
 Provides a RIOT support for Lora Serialization format.
 
 Lua ported to RIOT
 Provides a Lua interpreter for RIOT.
 
 Micro-ECC for RIOT
 Micro-ECC for RIOT.
 
 MicroPython RIOT port
 MicroPython - Python for microcontrollers.
 
 Microchip CryptoAuthentication Library
 Provides the library for Microchip CryptoAuth devices.
 
 Monocypher cryptographic library
 Provides the Monocypher cryptographic library.
 
 NanoCBOR library
 CBOR encoder and decoder library for tiny devices.
 
 NimBLE
 RIOT port of the NimBLE BLE stack.
 
 Nordic nrfx HAL
 Provides the Nordic nrfx HAL.
 
 OpenThread network stack
 Provides a RIOT adaption of the OpenThread network stack.
 
 OpenWSN network stack
 Provides a RIOT adaption of the OpenWSN network stack.
 
 PAHO MQTT framework
 The Eclipse Paho project provides open-source client implementations of MQTT for embedded systems.
 
 QCBOR for RIOT
 Small footprint CBOR encoder/decoder.
 
 QR Code generator
 QR Code generator library.
 
 Relic toolkit for RIOT
 Provides the Relic cryptographic toolkit to RIOT.
 
 SPI flash file system
 Provides a file system for SPI NOR flash devices.
 
 SX1261/2 LoRa radio driver
 This package is an implementation of the SX1261/2 LoRa radio driver.
 
 Semtech LoRaMAC implementation
 Provides a RIOT adaption of Semtech LoRaMAC implementation.
 
 Socketcan library
 Provides libsocketcan for native 32bit linux builds when not available otherwise.
 
 TLSF-based malloc.
 TLSF-based global memory allocator.
 
 Talking LEDs - Arduino library for demonstration
 Demonstrates the usage of Arduino libraries as packages.
 
 TensorFlow Lite
 Provides a RIOT support for TensorFlow Lite AI library.
 
 Tensorflow Lite Micro
 Portable C++ library for signal processing and machine learning inferencing.
 
 The ruy matrix multiplication library
 ruy is a matrix multiplication library
 
 Tiny VCDIFF
 Decoder for interleaved VCDIFF deltas.
 
 TinyCBOR library
 Provides the TinyCBOR (Concise Binary Object Representation) library.
 
 TinyDTLS for RIOT
 Provides the Eclipse TinyDTLS to RIOT.
 
 TinyUSB package
 Provides the tinyUSB stack as package.
 
 TweetNaCl high-security cryptographic library
 Provides the TweetNaCl high-security cryptographic library.
 
 Two-Level Segregated Fit memory allocator
 TLSF is a general purpose dynamic memory allocator specifically designed to meet real-time requirements:
 
 U8G2 graphic library for monochome displays
 Provides a monochrome graphics library for OLED and LCD displays.
 
 Ultra-lightweight Javascript for Internet Of Things
 Provides Javascript support for RIOT.
 
 Vendor library for EFM/EFR/EZR32 MCUs
 Vendor library for EFM/EFR/EZR32 targets by Silicon Labs.
 
 Wakaama LwM2M implementation
 Provides the Wakaama implementation of LwM2M.
 
 WebAssembly Micro Runtime
 Provides WebAssembly support for RIOT.
 
 WolfSSL Embedded SSL/TLS library
 Provides the WolfSSL SSL/TLS solution.
 
 Yxml XML parser
 Provides an XML parser library.
 
 cn-cbor
 A constrained node implementation of CBOR in C.
 
 emlearn
 Machine Learning inference engine.
 
 libcose for RIOT
 Constrained node COSE library.
 
 littlefs file system
 A little fail-safe filesystem designed for embedded systems.
 
 littlefs v2.x.y file system
 A little fail-safe filesystem designed for embedded systems, v2.x.y release.
 
 lwIP network stack
 Provides the lwIP network stack.
 
 mynewt-core
 Apache MyNewt package for MyNewt based packages: uwb-core, nimble.
 
 qdsa
 Small and Secure Digital Signatures with Curve-based Diffie-Hellman Key Pairs.
 
 small Protocol Buffers library
 Provides a protocol buffers library to RIOT.
 
 small Reed-Solomon code implementation
 Provides a tiny, performant implementation of reed solomon codes.
 
 tinycrypt crypto library
 Memory optimized crypto library for embedded devices.
 
 uBASIC interpreter
 A really tiny BASIC interpreter.
 
 uTensor
 Provides a package for AI inference based on TensorFlow.
 
 uzlib
 Deflate/Zlib-compatible LZ77 compression/decompression library.