RIOT - The friendly OS for IoT
RIOT is a multi-threading operating system which enables soft real-time capabilities and comes with support for a range of devices that are typically found in the Internet of Things: 8-bit and 16-bit microcontrollers as well as light-weight 32-bit processors.
RIOT is based on the following design principles: energy-efficiency, soft real-time capabilities, small memory footprint, modularity, and uniform API access, independent of the underlying hardware (with partial POSIX compliance).
RIOT is developed by an international open-source community which is independent of specific vendors (e.g. similarly to the Linux community) and is licensed with a non-viral copyleft license (LGPLv2.1), which allows indirect business models around the free open-source software platform provided by RIOT.
The 2024.01 release includes:
MTD_NUMOF definition from board.h
MTD_XFA_ADD(<mtd_dev>, <idx>); to the definition of <mtd_dev>.MTD_0, MTD_1, … defines are no longer needed. Use mtd_dev_get(0),
mtd_dev_get(1), … instead.native now is supported in pytermtests/periph/uart_locate_pins helps discover which pins are whereperiph_timer API supports periph_timer_query_freqs
194 pull requests, composed of 475 commits, have been merged since the last release, and 4 issues have been solved. 30 people contributed with code in 64 days. 1083 files have been touched with 36196 (+) insertions and 4976 deletions (-).
+ means new feature/item
* means modified feature/item
- means removed feature/item
extern mtd_dev_t *mtd<n> declarations from board
definitions (#20104)And 52 minor changes.
None
mtd_dev_xfa (#20113)timer_set() underflow safety check (tracking issue) (#13072)RIOTBOOT_MAGIC on stm32wb (#15917)buildtest uses wrong build directory (#9742)make term no longer works with JLinkExe v6.94 (#16022)make flash reports "device unsupported" (#17722)periph_timer (#18976)newlib lock functions. (#12732)byteorder.h need a cleanup (#14737)There are 158 known issues in this release
native (#20265)4 fixed issues since last release (2023.10)
We would like to thank all companies that provided us with hardware for porting and testing RIOT-OS. Further thanks go to companies and institutions that directly sponsored development time. And finally, big thanks to all of you contributing in so many different ways to make RIOT worthwhile!
All code files contain licensing information.
RIOT is a multi-threading operating system which enables soft real-time capabilities and comes with support for a range of devices that are typically found in the Internet of Things: 8-bit and 16-bit microcontrollers as well as light-weight 32-bit processors.
RIOT is based on the following design principles: energy-efficiency, soft real-time capabilities, small memory footprint, modularity, and uniform API access, independent of the underlying hardware (with partial POSIX compliance).
RIOT is developed by an international open-source community which is independent of specific vendors (e.g. similarly to the Linux community) and is licensed with a non-viral copyleft license (LGPLv2.1), which allows indirect business models around the free open-source software platform provided by RIOT.
The 2023.10 release includes:
116 pull requests, composed of 318 commits, have been merged since the last release, and 2 issues have been solved. 23 people contributed with code in 95 days. 1109 files have been touched with 437877 (+) insertions and 3189 deletions (-).
+ means new feature/item
* means modified feature/item
- means removed feature/item
And 13 minor changes.
timer_set() underflow safety check (tracking issue) (#13072)RIOTBOOT_MAGIC on stm32wb (#15917)buildtest uses wrong build directory (#9742)make term no longer works with JLinkExe v6.94 (#16022)make flash reports "device unsupported" (#17722)periph_timer (#18976)newlib lock functions. (#12732)byteorder.h need a cleanup (#14737)There are 161 known issues in this release
2 fixed issues since last release (2023.07)
We would like to thank all companies that provided us with hardware for porting and testing RIOT-OS. Further thanks go to companies and institutions that directly sponsored development time. And finally, big thanks to all of you contributing in so many different ways to make RIOT worthwhile!
All code files contain licensing information.
RIOT is a multi-threading operating system which enables soft real-time capabilities and comes with support for a range of devices that are typically found in the Internet of Things: 8-bit and 16-bit microcontrollers as well as light-weight 32-bit processors.
RIOT is based on the following design principles: energy-efficiency, soft real-time capabilities, small memory footprint, modularity, and uniform API access, independent of the underlying hardware (with partial POSIX compliance).
RIOT is developed by an international open-source community which is independent of specific vendors (e.g. similarly to the Linux community) and is licensed with a non-viral copyleft license (LGPLv2.1), which allows indirect business models around the free open-source software platform provided by RIOT.
This release sees the addition of the openDSME IEEE 802.15.4 MAC. So far it is limited to 2.4 GHz O-QPSK and drivers that have been converted to the new sub-MAC architecture yet.
We also have two new supported MCUs: nRF53 and ATmega8. They share common peripherals with their siblings, for nRF53 only the application core is supported so far.
Finally, all tests live in subdirectories now, so the tests/ directory is much more orderly.
288 pull requests, composed of 661 commits, have been merged since the last release, and 35 issues have been solved. 26 people contributed with code in 96 days. 6844 files have been touched with 251875 (+) insertions and 224148 deletions (-).
+ means new feature/item
* means modified feature/item
- means removed feature/item
/usr/bin/env to lookup Python. (#19448)And 65 minor changes.
const volatile modifiers (#19544)make debug and make debugserver (#19556)timer_set() underflow safety check (tracking issue) (#13072)RIOTBOOT_MAGIC on stm32wb (#15917)buildtest uses wrong build directory (#9742)make term no longer works with JLinkExe v6.94 (#16022)make flash reports "device unsupported" (#17722)periph_timer (#18976)newlib lock functions. (#12732)byteorder.h need a cleanup (#14737)There are 161 known issues in this release
samr21-xpro with ECC (#18292)"PRIu8" (#17083)make -j flash fails due to missing make dependencies or make flash-only rebuilds the .elf (#16385)export in make and immediate
evaluation (#10850)35 fixed issues since last release (2023.04)
We would like to thank all companies that provided us with hardware for porting and testing RIOT-OS. Further thanks go to companies and institutions that directly sponsored development time. And finally, big thanks to all of you contributing in so many different ways to make RIOT worthwhile!
All code files contain licensing information.
RIOT is a multi-threading operating system which enables soft real-time capabilities and comes with support for a range of devices that are typically found in the Internet of Things: 8-bit and 16-bit microcontrollers as well as light-weight 32-bit processors.
RIOT is based on the following design principles: energy-efficiency, soft real-time capabilities, small memory footprint, modularity, and uniform API access, independent of the underlying hardware (with partial POSIX compliance).
RIOT is developed by an international open-source community which is independent of specific vendors (e.g. similarly to the Linux community) and is licensed with a non-viral copyleft license (LGPLv2.1), which allows indirect business models around the free open-source software platform provided by RIOT.
The 2023.04 release includes:
280 pull requests, composed of 595 commits, have been merged since the last release, and 3 issues have been solved. 27 people contributed with code in 83 days. 1246 files have been touched with 177090 (+) insertions and 36429 deletions (-).
+ means new feature/item
* means modified feature/item
- means removed feature/item
fflush(); stdio_write() instead of fwrite() (#19250)esp_idf_api) (#19426)compile_like_murdock.py when board is empty (#19370)And 57 minor changes.
samr21-xpro with ECC (#18292)timer_set() underflow safety check (tracking issue) (#13072)RIOTBOOT_MAGIC on stm32wb (#15917)buildtest uses wrong build directory (#9742)make -j flash fails due to missing make dependencies or make flash-only rebuilds the .elf (#16385)export in make and immediate
evaluation (#10850)make term no longer works with JLinkExe v6.94 (#16022)make flash reports "device unsupported" (#17722)"PRIu8" (#17083)newlib lock functions. (#12732)There are 156 known issues in this release
3 fixed issues since last release (2023.01)
esp32-wroom-32 PASSnrf52840dk PASSnucleo-f429zi PASSsamr21-xpro PASSarduino-mega2560 FAILb-l072z-lrwan1 FAILb-l475e-iot01a FAILdwm1001 FAILfrdm-kw41z FAILiotlab-m3 FAILnrf52dk FAILnucleo-l452re FAILnucleo-wl55jc FAILremote-revb FAILsaml10-xpro FAILsamr34-xpro FAILSee the release tracking issue (#19469) for more details.
We would like to thank all companies that provided us with hardware for porting and testing RIOT-OS. Further thanks go to companies and institutions that directly sponsored development time. And finally, big thanks to all of you contributing in so many different ways to make RIOT worthwhile!
All code files contain licensing information.
RIOT is a multi-threading operating system which enables soft real-time capabilities and comes with support for a range of devices that are typically found in the Internet of Things: 8-bit and 16-bit microcontrollers as well as light-weight 32-bit processors.
RIOT is based on the following design principles: energy-efficiency, soft real-time capabilities, small memory footprint, modularity, and uniform API access, independent of the underlying hardware (with partial POSIX compliance).
RIOT is developed by an international open-source community which is independent of specific vendors (e.g. similarly to the Linux community) and is licensed with a non-viral copyleft license (LGPLv2.1), which allows indirect business models around the free open-source software platform provided by RIOT.
We are proud to announce the release of RIOT 2023.01, marking the tenth anniversary of the project. Over the past decade, RIOT has become a thriving open-source community, delivering cutting-edge technology for Internet of Things (IoT) devices. This release builds on top of the hard work and dedication of our developers, users, and contributors, and we would like to extend a heartfelt thank you to everyone who has been a part of our journey. Here's to another decade of innovation and growth!
Noteworthy changes the 2023.01 release includes, among many fixes and little things:
187 pull requests, composed of 570 commits, have been merged since the last release, and 13 issues have been solved. 37 people contributed with code in 58 days. 1248 files have been touched with 516544 (+) insertions and 12047 deletions (-).
+ means new feature/item
* means modified feature/item
- means removed feature/item
And 38 minor changes.
event_callback before calling init (#18745)samr21-xpro with ECC (#18292)timer_set() underflow safety check (tracking issue) (#13072)RIOTBOOT_MAGIC on stm32wb (#15917)buildtest uses wrong build directory (#9742)make -j flash fails due to missing make dependencies or make flash-only rebuilds the .elf (#16385)export in make and immediate
evaluation (#10850)make term no longer works with JLinkExe v6.94 (#16022)make flash reports "device unsupported" (#17722)"PRIu8" (#17083)newlib lock functions. (#12732)There are 151 known issues in this release
13 fixed issues since last release (2022.10)
We would like to thank all companies that provided us with hardware for porting and testing RIOT-OS. Further thanks go to companies and institutions that directly sponsored development time. And finally, big thanks to all of you contributing in so many different ways to make RIOT worthwhile!
All code files contain licensing information.
RIOT is a multi-threading operating system which enables soft real-time capabilities and comes with support for a range of devices that are typically found in the Internet of Things: 8-bit and 16-bit microcontrollers as well as light-weight 32-bit processors.
RIOT is based on the following design principles: energy-efficiency, soft real-time capabilities, small memory footprint, modularity, and uniform API access, independent of the underlying hardware (with partial POSIX compliance).
RIOT is developed by an international open-source community which is independent of specific vendors (e.g. similarly to the Linux community) and is licensed with a non-viral copyleft license (LGPLv2.1), which allows indirect business models around the free open-source software platform provided by RIOT.
The 2022.10 release includes, among many many bug fixes and improvements, the following prominent contributions:
The GNRC network stack has received a number of security fixes. All users of GNRC are advised to update to the new release. Given that no user facing breaking API changes are included, we are hopeful that the update is painless and quickly possible.
RIOT has been ported to the ESP32-C3, ESP32-S2, and the ESP32-S3 MCUs. In addition driver support for the integrated BLE transceiver of the ESP32 MCUs has been added.
While the CI is developed in an independent repository, it is still a noteworthy change that our CI software, Murdock, was updated since the last release. In addition to changes under the hood the web front end got a major revamp. You will directly notice the improvements in page load time and clarity/structure of the interface. If you haven't already, please check out https://ci.riot-os.org to take a look.
core_mutexIf a shared resource guarded by a mutex is used by a high priority and a low priority thread, the high priority thread may end up waiting on the low priority thread to return the resource. If medium priority threads now interrupt the low priority thread while working with the shared resource, the high priority thread ends up waiting on both medium and low priority threads. This effect is called priority inversion.
Priority inversion can in most cases be solved by carefully assigning priorities
and resources. In some cases however, this cannot be avoided: Let's consider
a scenario in which an I2C temperature sensor and an I2C IMU are used. Since
temperature changes are slow in frequency, the temperature readings are
assigned the lowest priority, while the IMU readings are assigned the highest
priority. The sensible approach here is to have both sensors on distinct I2C
buses. However, if e.g. only a single I2C bus is available by the hardware
priority inversion cannot be prevented by careful resource and priority
assignment alone. In these cases the module core_mutex_priority_inheritance
can be used to lend the low priority thread the priority of the high priority
thread while the high priority thread is waiting for the mutex hold by the
low priority thread.
After RIOT has already been launched into space it is now ready to for Mars.
While RIOT has longstanding USB support for many STM32 MCU families, the F1 family was not supported due to some peculiarities in the memory layout. The driver has now been extended to handle them correctly. With this, the popular STM32F103 bluepill board now supports stdio via USB, which however still has to be manually enabled e.g. by:
USEMODULE=stdio_cdc_acm BOARD=bluepill make -C examples/default
Just add an export DOCKER=podman to your ~/.profile (or ~/.bashrc, or ...)
and an make BUILD_IN_DOCKER=1 will use podman instead of
docker to run the RIOT build container. Two major advantages of using podman
over docker is the support of rootless containers and not depending on a
central background daemon.
The nRF52 MCUs have a limited number of combined I2C/SPI peripherals. Previously, each such peripheral could either provide a single I2C or a single SPI bus. A board configuration that used the same combined peripheral to provide both an SPI and an I2C bus previously resulted in bad surprises at run-time.
The I2C/SPI drivers have now been reworked so that they can be shared in round-robin fashion between multiple I2C and SPI buses. This is especially useful for the upcoming support of the Bangle.js 2 watch that uses more I2C buses than combined I2C/SPI peripherals available on the used nRF52840 MCU. Thanks to the sharing of peripherals, all I2C buses can now be provided by a single peripheral.
Many fixes for compilation and runtime issues that only started to surface with GCC 12.2.0 have been fixed. This allows our users to confidentially choose the current release with little to no fear that toolchain updates in the near future will break the precious projects. In addition, we hope that the next CI update will also cause less friction.
312 pull requests, composed of 819 commits, have been merged since the last release, and 29 issues have been solved. 47 people contributed with code in 84 days. 1799 files have been touched with 56827 (+) insertions and 108634 deletions (-).
+ means new feature/item
* means modified feature/item
- means removed feature/item
strerror() implementation (#18571)cpu_switch_context_exit() (#18697)cortexm.ld (#18636)shell_cmd_<name> module. What previously was called shell_commands now
is shell_cmds_default and will automagically select shell commands based
on the set of modules used. Users can keep using shell_commands for now,
but the build system will inform them that shell_commands is deprecated..pin member and rename the existing .muxpos member to .inputctrl
gnrc_netreg_lookup() and gnrc_netreg_getnext() now need to be
guardedvoid * instead of uint8_t * (#18941)
char * to uint8_t *
And 40 minor changes.
shell_commands is now deprecated. User should use
shell_cmds_default. For now, shell_commands is an alias of
shell_cmds_default
shell_cmd_<name>, while they previously where
often called <name>_cmd. The previous names are aliases of the new names
and the build system will list any deprecated modules used.hashes_cmac should update to hashes_aes128_cmac before the legacy
wrappers now in place for backward compatibility will be removed.event_callback before calling init (#18751)samr21-xpro with ECC (#18292)timer_set() underflow safety check (tracking issue) (#13072)RIOTBOOT_MAGIC on stm32wb (#15917)buildtest uses wrong build directory (#9742)make -j flash fails due to missing make dependencies or make flash-only rebuilds the .elf (#16385)export in make and immediate
evaluation (#10850)make term no longer works with JLinkExe v6.94 (#16022)make flash reports "device unsupported" (#17722)"PRIu8" (#17083)newlib lock functions. (#12732)There are 161 known issues in this release
tests/thread_priority_inversion failing with esp32-wroom-32 (#18534)make term output is inconsistent between boards, ethos and
native (#12108)29 fixed issues since last release (2022.07)
We would like to thank all companies that provided us with hardware for porting and testing RIOT-OS. Further thanks go to companies and institutions that directly sponsored development time. And finally, big thanks to all of you contributing in so many different ways to make RIOT worthwhile!
All code files contain licensing information.
RIOT is a multi-threading operating system which enables soft real-time capabilities and comes with support for a range of devices that are typically found in the Internet of Things: 8-bit and 16-bit microcontrollers as well as light-weight 32-bit processors.
RIOT is based on the following design principles: energy-efficiency, soft real-time capabilities, small memory footprint, modularity, and uniform API access, independent of the underlying hardware (with partial POSIX compliance).
RIOT is developed by an international open-source community which is independent of specific vendors (e.g. similarly to the Linux community) and is licensed with a non-viral copyleft license (LGPLv2.1), which allows indirect business models around the free open-source software platform provided by RIOT.
The 2022.07 release includes many changes, some highlights of which are:
A new API, gpio_ll, has been introduced for highly efficient access to GPIO
pins grouped in ports.
The API is limited to internal use for the time being, but still paves the way towards using port multipliers like local GPIO pins, and for improved bit-banging implementations (e.g. around WS281x-style LEDs).
When using multiple boards simultaneously, a new serial port selection
algorithm can be activated by setting MOST_RECENT_PORT=1. Of all serial ports
whose metadata matches the board's known properties, it selects the most
recently connected one.
The ESP IDF (IoT Development Framework; the vendor's provided tools) has been upgraded to version 4.4, and many peripheral drivers are now implemented using those.
343 pull requests, composed of 767 commits, have been merged since the last release, and 5 issues have been solved. 38 people contributed with code in 107 days. 1684 files have been touched with 43451 (+) insertions and 82174 deletions (-).
+ means new feature/item
* means modified feature/item
- means removed feature/item
__restrict instead of restrict (#18034)_builtin_cmds define (#18075)drivers/mtd_mapper: inherit physical properties (#18113)
drivers/netdev_ieee802154: drop duplicate struct member (#17979)
drivers/periph_common/cpuid: disable false positive warnings (#17909)
drivers/hd44780: PCF857x I2C interface added (#12665)
drivers/ir_nec: NEC remote receiver implementation (#17935)
drivers/mcp2515: enable filtering (#18062)
drivers/mcp2515: apply filters to target mailbox (#18131)
drivers/mcp2515: fixes and cleanups (#17945)
drivers/scard_spi: _dyn_spi_rxtx_byte return void (#17968)
drivers/ws281x: update ESP32 driver to use ESP-IDF CPU HAL (#18252)
pkg/driver_atwinc15x0: bump version to 1.6.1 (#18215)
2>&1 >/dev/null, and weed out remaining offenders (#16806)And countless minor changes.
extern const out of static inline functions (#18140)samr21-xpro with ECC (#18292)timer_set() underflow safety check (tracking issue) (#13072)RIOTBOOT_MAGIC on stm32wb (#15917)buildtest uses wrong build directory (#9742)make -j flash fails due to missing make dependencies or make flash-only rebuilds the .elf (#16385)export in make and immediate
evaluation (#10850)make term no longer works with JLinkExe v6.94 (#16022)make term output is inconsistent between boards, ethos and
native (#12108)make flash reports "device unsupported" (#17722)"PRIu8" (#17083)newlib lock functions. (#12732)There are 188 known issues in this release
5 fixed issues since last release (2022.04)
We would like to thank all companies that provided us with hardware for porting and testing RIOT-OS. Further thanks go to companies and institutions that directly sponsored development time. And finally, big thanks to all of you contributing in so many different ways to make RIOT worthwhile!
All code files contain licensing information.
RIOT is a multi-threading operating system which enables soft real-time capabilities and comes with support for a range of devices that are typically found in the Internet of Things: 8-bit and 16-bit microcontrollers as well as light-weight 32-bit processors.
RIOT is based on the following design principles: energy-efficiency, soft real-time capabilities, small memory footprint, modularity, and uniform API access, independent of the underlying hardware (with partial POSIX compliance).
RIOT is developed by an international open-source community which is independent of specific vendors (e.g. similarly to the Linux community) and is licensed with a non-viral copyleft license (LGPLv2.1), which allows indirect business models around the free open-source software platform provided by RIOT.
The 2022.04 release includes the following new features and improvements:
The scheduler allows for changing the priority of a thread at runtime.
The module ztimer64_xtimer_compat was added, providing the complete xtimer
API on top of ztimer64_usec. This is now the default implementation when using
the xtimer module.
Most modules use ztimer instead of xtimer now.
The sequence of modules during auto initialization can be customized via statically assigned numbers now. This feature is experimental, so use it with caution. Priorities may change in the future.
SenML implementation: supports CBOR encoding, Phydat to SenML encoding and basic SAUL integration.
Various improvements have been made to the file system modules: VFS supports automatic mount (and formatting) at startup and reliable disk enumeration, and mount_by_path. Default mount points can be provided by the board configuration. exFAT support was added to FATFS.
Using Rust in RIOT no longer requires a nightly version of Rust, but can be built on the latest stable on Rust instead.
Boards no longer have to provide a board_init() function. LEDs are
initialized automatically if they follow the LED<x>_PIN naming scheme.
gcoap now provides a simple forward-proxy and allows for switching between plain CoAP and CoAP-over-DTLS at runtime.
The NimBLE module supports the new PHY modes that have been introduced with Bluetooth 5.
A Telnet server module is available now.
The build system now allows for package directories to reside outside the RIOT tree.
Various new packages have been added:
New support for the boards Adafruit-PyBadge and STM32 Nucleo-F439ZI as well as for the LPS22CH nano pressure sensor and MCP47xx DAC. The DOSE bus now supports baud rates of 1 MHz and above.
328 pull requests, composed of 810 commits, have been merged since the last release, and 6 issues have been solved. 40 people contributed with code in 83 days. 1851 files have been touched with 50235 (+) insertions and 18701 deletions (-).
+ means new feature/item
* means modified feature/item
- means removed feature/item
xtimer_is_set() (#17630)nanocoap_sock_*(), use in
suit/transport/coap (#17474)git am if there are no patches (#17858)$(BINDIR) size (#17213)And 57 minor changes.
/dev/null (#17873)ztimer64_remove() not properly clearing timer
struct (#17720)timer_set() underflow safety check (tracking issue) (#13072)RIOTBOOT_MAGIC on stm32wb (#15917)buildtest uses wrong build directory (#9742)make -j flash fails due to missing make dependencies or make flash-only rebuilds the .elf (#16385)export in make and immediate
evaluation (#10850)make term no longer works with JLinkExe v6.94 (#16022)make term output is inconsistent between boards, ethos and
native (#12108)make flash reports "device unsupported" (#17722)"PRIu8" (#17083)newlib lock functions. (#12732)There are 185 known issues in this release
genconfig.py rewrites /dev/null (#17862)4 fixed issues since last release (2022.01)
We would like to thank all companies that provided us with hardware for porting and testing RIOT-OS. Further thanks go to companies and institutions that directly sponsored development time. And finally, big thanks to all of you contributing in so many different ways to make RIOT worthwhile!
All code files contain licensing information.
RIOT is a multi-threading operating system which enables soft real-time capabilities and comes with support for a range of devices that are typically found in the Internet of Things: 8-bit and 16-bit microcontrollers as well as light-weight 32-bit processors.
RIOT is based on the following design principles: energy-efficiency, soft real-time capabilities, small memory footprint, modularity, and uniform API access, independent of the underlying hardware (with partial POSIX compliance).
RIOT is developed by an international open-source community which is independent of specific vendors (e.g. similarly to the Linux community) and is licensed with a non-viral copyleft license (LGPLv2.1), which allows indirect business models around the free open-source software platform provided by RIOT.
The 2022.01 release brings support for new packages, new boards and drivers, as well as several package upgrades and bug fixes. Among others, this release improves the RIOT codebase with:
RIOT now offers convenient integration of Rust application programming, with wrappers interfacing to RIOT modules such as timers, network stack.
Many modules have migrated from using xtimer to our more power-efficient alternative ztimer. Also, ztimer64 was introduced, which enables a drop-in replacement for all of xtimer features.
Kconfig modeling coverage is significantly extended. Nearly all supported boards are now modeled with Kconfig.
436 pull requests, composed of 1159 commits, have been merged since the last release, and 11 issues have been solved. 43 people contributed with code in 88 days. 2475 files have been touched with 44925 (+) insertions and 14687 deletions (-).
+ means new feature/item
* means modified feature/item
- means removed feature/item
Full list available at https://github.com/RIOT-OS/RIOT/milestone/37?closed=1
\.[ch]$ (#17405)-no-pie to LINKFLAGS (#16186)arch_% cpu_core_% features first (#17224)FULL_BUILD==1 (#17495)timer_set() underflow safety check (tracking issue) (#13072)RIOTBOOT_MAGIC on stm32wb (#15917)buildtest uses wrong build directory (#9742)make -j flash fails due to missing make dependencies or make flash-only rebuilds the .elf (#16385)export in make and immediate
evaluation (#10850)make term no longer works with JLinkExe v6.94 (#16022)make term output is inconsistent between boards, ethos and
native (#12108)"PRIu8" (#17083)newlib lock functions. (#12732)There are 179 known issues in this release
native when using IPV4 (#17144)murdock and
riot/riotbuild:latest image (#9645)11 fixed issues since last release (2021.10)
We would like to thank all companies that provided us with hardware for porting and testing RIOT-OS. Further thanks go to companies and institutions that directly sponsored development time. And finally, big thanks to all of you contributing in so many different ways to make RIOT worthwhile!
All code files contain licensing information.
RIOT is a multi-threading operating system which enables soft real-time capabilities and comes with support for a range of devices that are typically found in the Internet of Things: 8-bit and 16-bit microcontrollers as well as light-weight 32-bit processors.
RIOT is based on the following design principles: energy-efficiency, softreal-time capabilities, small memory footprint, modularity, and uniform API access, independent of the underlying hardware (with partial POSIX compliance).
RIOT is developed by an international open-source community which is independent of specific vendors (e.g. similarly to the Linux community) and is licensed with a non-viral copyleft license (LGPLv2.1), which allows indirect business models around the free open-source software platform provided by RIOT.
The 2021.10 release includes:
The last three months again brought many new features, fixes and improvements to the RIOT codebase. There is new hardware support, new helper functions and many new modules that help with building IoT applications.
Some of the new features are:
The GCOAP CoAP library now supports transport encryption via tinyDTLS. This is a compile-time toggle, so either all requests are encrypted or none. There is already a PR (#16688) that will allow to mix encrypted and unencrypted requests.
We now have an implementation of the Fast Identity Online 2 (FIDO2) specification. With this you can use any RIOT device with USB support as an authentication token similar to the YubiKey.
The 6LoWPAN over Bluetooth Low Energy module has gained support for the RPL routing protocol. With this it's now possible to set up IPv6 based mesh networks over BLE on chips supported by the Nimble Bluetooth stack.
RIOT's native GNRC network stack now has support for the TCP protocol via the socket API. Now you can switch between LWIP and GNRC without changing your application.
The DHCP module can now act as a relay, forwarding DHCPv6 requests for multihop-operation.
The DHCPv6 client can now also request non-temporary addresses as an alternative to Stateless Access Autoconfiguration (SLAAC) that is used by default.
The feature can be enabled by selecting the dhcpv6_client_ia_na module.
This new module allows to split a large IPv6 prefix into smaller ones that can be used to configure downstream interfaces with a prefix. The process can be repeated recursively for a cascading subnet topology.
This can be a lightweight alternative to DHCPv6 that only relies on router advertisements.
For more details on this, see the talk at the 2021 RIOT summit.
The examples section has gained a UDP benchmark.
This can be used as a network stress test and is accompanied by a host tool (dist/tools/benchmark_udp) that acts as the benchmark server to which the benchmark clients will connect.
URI templates up to level 3 (according to RFC 6570) can now be parsed with this tool.
RIOT's native bootloader has gained the ability to load a firmware via UART. This allows to program a board without the need for external programmers, a serial console is enough.
Many real-time clocks have the ability to store a few bytes in their memory as user data. This memory is retained across reboots and deep sleep.
We now have an interface for this feature and implemented it on SAM L21, SAM D5x/E5x and STM32.
The alternative LWIP network stack can now make use of multiple interfaces. Initialisation is done using the new XFA (cross-file array) feature so new drivers can be added by only adding a single file.
With socket_zep and the ZEP dispatcher it is possible to simulate a virtual IEEE 802.15.4 network with native nodes.
ZEP dispatcher has now gained support for lossy connections that make this simulation behave closer to reality.
There are also PRs pending to automatically generate such topologies (#16889) and to hook up the ZEP dispatcher to the foren6 network visualizer (#16879).
We have added a RIOT_VERSION_CODE macro that can be used by external modules / boards to check against which RIOT version it is compiled.
This allows to react to API changes if the module is built against different versions of RIOT.
gnrc_netif_ipv6_wait_for_global_address() (#16824)For apps that want to connect to a remote server, send some data and then go back to sleep, there is now the new gnrc_netif_ipv6_wait_for_global_address() function.
This function blocks until a global address has been configured (e.g. via router advertisement) or a timeout happens. So no more guessing if a connection can yet be established or if the interface is not configured yet.
This feature depends on the gnrc_netif_bus module.
netutils_get_ipv6() (#16634)This simple function can parse a IPv6 address from a string.
But that's not all - if the sock_dns module is enabled, the string can also be a hostname which will then be resolved.
This provides a small and simple alternative to getaddrinfo() that can be used by shell commands and applications alike.
On Linux the ping command from iputils has the neat feature that it fills the payload with of the ICMP echo request with a pattern that is then echoed back by the receiver.
That means it can detect if the payload got corrupted on the way, e.g. by broken fragmentation or other errors.
The RIOT ping command now also implements this feature that lets you easily detect if something broke along the way.
In this cycle we have seen the addition of three new MCU families! Our latest additions are the Raspberry Pi RP2040 (#16609) and the GD32VF103 RISC-V MCU from GigaDevice (#16036).
Both only have very basic support so far (only GPIO, UART and timers), which still leaves many low hanging fruits for adding peripheral drivers. (#15822, #16935) Patches welcome!
The nRF9160 is closer to it's nRF52 siblings (#16650), but brings GPS and LTE-M/NB-IoT peripherals. While we are not there yet, there is ongoing work to also support these in RIOT.
The ATxmega family of 8-bit MCUs can now make use of the EBI interface to use external memory. (#16288) The new XMEGA-A1 Xplained already makes use of this feature. (#15758)
On the STM32 side we have now support for the nucleo-wl55jc and it's LoRa transceiver.
The IEEE 802.15.4 / BLE radio on the STM32WB family is however still waiting for a driver.
The common LM75 family of temperature drivers is now supported by RIOT. (#16678)
The Ethernet driver for the SAM E5x line of MCUs is now stable. (#16683)
The sub-MAC layer that implements common MAC features for IEEE 802.15.4 radios has again seen many improvements. It is currently used by the nRF52 and CC2538 line of MCUs.
The spi_acquire() no longer returns an error code but will throw an assertion
if called with the wrong parameters.
This allows to speed up SPI operations a bit as SPI parameters are usually fixed
at compile time.
The gnrc_netdev_default was replaced by the network stack agnostic
netdev_default module.
For now gnrc_netdev_default remains an alias for netdev_default, but it will
be removed in a future release.
263 pull requests, composed of 590 commits, have been merged since the last release, and 14 issues have been solved. 36 people contributed with code in 98 days. 1756 files have been touched with 138909 (+) insertions and 12027 deletions (-).
+ means new feature/item
* means modified feature/item
- means removed feature/item
event_timeout for non-sock timeouts (#16668)test-with-config (#16795)which from shell invocations (#16776)\0-terminated. (#16712)And 63 minor changes.
get functions (#16691)which from shell invocations" (#16803)timer_set() underflow safety check (tracking issue) (#13072)RIOTBOOT_MAGIC on stm32wb (#15917)buildtest uses wrong build directory (#9742)make -j flash fails due to missing make dependencies or make flash-only rebuilds the .elf (#16385)murdock and
riot/riotbuild:latest image (#9645)export in make and immediate
evaluation (#10850)make term no longer works with JLinkExe v6.94 (#16022)make term output is inconsistent between boards, ethos and
native (#12108)newlib lock functions. (#12732)There are 173 known issues in this release
main (#16977)examples/dtls-sock with
CONFIG_DTLS_ECC enabled (#16873)14 fixed issues since last release (2021.07)
We would like to thank all companies that provided us with hardware for porting and testing RIOT-OS. Further thanks go to companies and institutions that directly sponsored development time. And finally, big thanks to all of you contributing in so many different ways to make RIOT worthwhile!
All code files contain licensing information.