libembedded - Modern C++ for Embedded Systems

This library will hopefully, over time, become a collection of useful, modern C++ abstractions, with a particular focus on being useful in the context of embedded systems.

The goal for this library is to provide abstractions that

• work nicely without exceptions and RTTI enabled,

• work nicely without dynamic memory allocation and

• require only C++11 compliant compilers.

What's inside

A polymorphic function wrapper with in-place storage

embedded::function is loosely modeled after std::function and inspired by both SG14's inplace_function and folly::Function. It requires no dynamic memory allocation, but, contrary to etl::delegate, is able to wrap lambdas and other function objects as long as they fit into the in-place storage.

A circular buffer adapter

The circular_buffer_adapter template allows the construction of circular buffers on top of a arbitrary, and possibly persistent, memory. This means that you can easily build circular buffers on top of EEPROM sections.

Variable length integers

embedded::varint implements encoding and decoding of interger values to and from byte streams, using as few bytes as possible, and independent of byte order.

Type traits

A few type traits have been back-ported from later C++ standards. More will be added on-demand.

An experimental compile-time IIR filter design library

This library (in embedded/signal) can be used to directly design IIR filters in C++ code without any run-time overhead. This is currently in experimental state as the interface isn't yet settled and there's quite a few things that are still missing. However, you can do things like:

constexpr auto design =
    iirfilter<>(1000.0).lowpass(chebyshev1<8>(3.0), 40.0).sos<float>();

auto filter = design.instance();

for (;;) {
    output(filter(input()));
}

This will design an 8th-order Chebyshev Type I low-pass filter with 3 dB of passband ripple, a sample rate of 1 kHz and a cutoff frequency of 40 Hz. All filter coefficients will be determined at compile-time and the run-time filter code is extremely efficient. For example, this is the full ARM assembly for the above code, but using a second-order filter:

process():
        push            {r3, lr}
        vpush.64        {d8, d9, d10}
        vldr.32         s17, .L5
        vldr.32         s20, .L5+4
        vldr.32         s19, .L5+8
        vmov.f32        s16, s17
        vldr.32         s18, .L5+12
.L2:
        bl              input()
        vmul.f32        s13, s0, s20
        vmov.f32        s15, s0
        vldr.32         s12, .L5+16
        vadd.f32        s14, s16, s13
        vmul.f32        s16, s14, s18
        vmls.f32        s13, s14, s12
        vmov.f32        s0, s14
        vnmls.f32       s16, s15, s19
        vadd.f32        s16, s16, s17
        vmov.f32        s17, s13
        bl              output(float)
        b               .L2
.L5:
        .word   0
        .word   1005574271
        .word   1013962879
        .word   -1075339548
        .word   1062851613

The library is also able to build fixed-point arithmetic filters if a suitable fixed-point implementation is provided (e.g. fpm).

You can find examples in the examples directory of the repo.

Experimental compile-time math library

This is primarily used by the compile-time filter design library and currently only contains the minimum functionality needed to implement the filter design. It does contain things like constexpr functions (provided either via libstdc++'s non-standard builtins or via the gcem library), constexpr complex numbers and constexpr vectors.