A collection of low-level interface modules, drivers and BSPs (board support packages) designed to provide the foundation of a successful embedded software design. Whether for a bare-metal project or with your choice of free or commercial RTOS, BASEplatform can help to smoothly integrate multiple RTOS components from various sources.
Modules and Features
- Choice of blocking, non-blocking and asynchronous API
- Consistent and robust error handling
- Optional timeout on any blocking calls
- Low jitter sub-millisecond delays and timers
- Thread-safe API and optional low resource/high performance non-thread-safe API
Modules and Peripherals
- Low level & RTOS startup code
- Interrupt management
- System tick, hardware timers and watchdogs
- Low speed I/O UART, I2C, SPI & GPIO
- High speed IO Ethernet, QSPI, MIPI and more
- SoC level peripherals, clock & reset.
Why should you use the BASEplatorm?
Often disregarded due to their apparent simplicity, low level peripheral drivers can often be a source of problems early during the bring-up phase. Incorrectly tackling those early issues will often translate in hard to find bugs and unforeseen limitations in later stages of an application development.
BASEplatform offers a modular and robust set of peripheral drivers supported on many different architectures, toolchains and RTOSes. Those features grant the application developer the freedom of choosing its preferred combination of hardware, software and development environment without compromise due to incomplete software integration.
The BASEplatform modular design offers unprecedented flexibility in the selection of hardware and software components for a project. Aside from the standard sets of peripherals, custom modules and drivers can be developed to fit all of an application needs.
Features and performance. Designed from the start to be a set of high quality peripheral interface modules, the BASEplatform can offer more features with better performance than most competing options.
Consistent and robust API. Since all the modules and drivers are designed and written from scratch the overall API is consistent from module to module. The error handling is also strictly implemented to offer the best possible reliability all the while reducing the development overhead. Finally, timeouts are optionally available on all blocking calls, enabling an easy defensive programming approach to handle unexpected deadlocks or peripheral failures.
Sub-millisecond, low jitter timers and delays. Many applications require timers and delays. When available on the selected platform, the BASEplatform can use high resolution hardware timers to provide low jitter sub-millisecond delays. This improves the efficiency of timing delays as well as enabling an application to obey strict timing constraints often critical to real-time applications.
Wide variety of API choice. Most modules of the BASEplatform offers three API flavours, blocking, non-blocking and asynchronous. Additionally, developers are provided with a thread safe API along with an optional low resource high performance non thread-safe API.
Which platforms can be supported?
The BASEplatform is designed to support the widest range of platforms, toolchains and RTOSes without compromising features and performance. Platform support can range from small low power MCU to large heterogeneous multi-core System on Chips. Here’s a short summary of the important system and toolchain requirements.
- 32 or 64-bit architecture is recommended for optimal performance.
- RAM and ROM requirements are dependent on the chosen RTOS. For estimation purposes, 3-5 KiB of ROM should be allocated per peripheral module and 64 bytes of RAM per peripheral instance when running in bare-metal.
- SMP (Symmetric MultiProcessing) platforms and AMP (Asymmetric MultiProcessing) applications on SMP processors (i.e. two RTOS instances on a dual core Cortex-A9) must be cache coherent. Additionally, for optimum performances SMP platforms should support a load-link/store-conditional instruction pair or equivalent.
- ISO/IEC 9899:1999 (a.k.a C99) compliant compiler.