Modern C++ for Firmware

// plain_enum.cpp - a plain C-style enum turns into a number without being asked
#include <cstdint>
#include <cstdio>

enum Colour { red, green, blue };           // the names red, green and blue are now global

static void set_pin(uint8_t pin) { std::printf("set_pin(%u)\n", static_cast<unsigned>(pin)); }

int main() {
    Colour c = blue;
    set_pin(c);                             // meant a pin number; got a colour; compiles anyway
    int total = red + blue;                 // arithmetic on colours: also compiles
    std::printf("red + blue = %d\n", total);
    return 0;
}

// enum_class.cpp - enum class: names that stay inside, and no quiet conversions
#include <cstdint>
#include <cstdio>

enum class Colour : uint8_t { red, green, blue };       // stored in one byte
enum class Alarm : uint8_t { off, red, amber };         // a second 'red', and no clash

static const char *name(Colour c) {
    switch (c) {
    case Colour::red:
        return "red";
    case Colour::green:
        return "green";
    case Colour::blue:
        return "blue";
    }
    return "?";
}

int main() {
    Colour c = Colour::blue;
    Alarm a = Alarm::red;
    std::printf("colour %s, stored as %u, in %zu byte\n", name(c), static_cast<unsigned>(c), sizeof c);
    std::printf("alarm level %u\n", static_cast<unsigned>(a));
    return 0;
}

// enum_convert.cpp - an enum class will not pass as a pin number
#include <cstdint>

enum class Colour : uint8_t { red, green, blue };

void set_pin(uint8_t pin);

void mistake() {
    set_pin(Colour::blue);
}

// switch_missing.cpp - a new state added, and one switch not updated
#include <cstdint>

enum class State : uint8_t { idle, running, stopped, fault };      // fault was added later

const char *describe(State s) {
    switch (s) {
    case State::idle:
        return "idle";
    case State::running:
        return "running";
    case State::stopped:
        return "stopped";
    }
    return "?";
}

// lambda.cpp - lambdas: small functions written where they are used
#include <cstdint>
#include <cstdio>

// A C-style timer driver: it calls back one plain function.
using callback_t = void (*)();
static callback_t timer_callback = nullptr;
static void timer_set_callback(callback_t cb) { timer_callback = cb; }

class Blinker {
public:
    void toggle() { on_ = !on_; }
    bool on() const { return on_; }

private:
    bool on_ = false;
};

static Blinker status_led;

// Calls f once for each sample. F can be any callable, and the compiler can see inside it.
template <typename F>
static void for_each_sample(const uint16_t *samples, int count, F f) {
    for (int i = 0; i < count; i++) {
        f(samples[i]);
    }
}

int main() {
    // 1. No captures: the lambda turns into a plain function pointer, so a C driver can take it.
    timer_set_callback([] { status_led.toggle(); });
    timer_callback();
    std::printf("after one tick: LED %s\n", status_led.on() ? "on" : "off");

    // 2. Captures: the lambda uses local variables - threshold by value, over by reference.
    const uint16_t samples[] = {510, 530, 890, 505, 920};
    uint16_t threshold = 800;
    int over = 0;
    for_each_sample(samples, 5, [threshold, &over](uint16_t s) {
        if (s > threshold) {
            over++;
        }
    });
    std::printf("%d samples over %u\n", over, static_cast<unsigned>(threshold));
    return 0;
}

// capture_callback.cpp - a lambda that captures cannot be a plain function pointer
using callback_t = void (*)();
void timer_set_callback(callback_t cb);

void setup(int &ticks) {
    timer_set_callback([&ticks] { ticks = ticks + 1; });
}

// optional.cpp - a value that may not be there, with no status code and no magic number
#include <cstdint>
#include <cstdio>
#include <optional>

static std::optional<int16_t> read_temperature(bool sensor_answers) {
    if (!sensor_answers) {
        return std::nullopt;                // "no reading"
    }
    return 25;
}

int main() {
    std::optional<int16_t> t = read_temperature(true);
    if (t) {                                // true only if there is a value
        std::printf("got %d C\n", *t);      // * reads the value: only after checking
    }

    std::optional<int16_t> missing = read_temperature(false);
    std::printf("missing has a value: %s\n", missing.has_value() ? "yes" : "no");
    std::printf("missing.value_or(-999) gives %d\n", missing.value_or(-999));
    std::printf("sizeof(std::optional<int16_t>) = %zu: the value and a flag\n", sizeof t);
    return 0;
}

// span.cpp - one function for every kind of buffer: std::span
#include <array>
#include <cstdint>
#include <cstdio>
#include <span>

// A span is a view of someone else's bytes: a pointer and a length, kept together.
static uint32_t checksum(std::span<const uint8_t> data) {
    uint32_t sum = 0;
    for (uint8_t b : data) {
        sum += b;
    }
    return sum;
}

int main() {
    uint8_t c_array[4] = {1, 2, 3, 4};
    std::array<uint8_t, 6> frame = {10, 20, 30, 40, 50, 60};

    std::printf("a C array:          %u\n", static_cast<unsigned>(checksum(c_array)));
    std::printf("a std::array:       %u\n", static_cast<unsigned>(checksum(frame)));
    std::printf("first 3 of frame:   %u\n", static_cast<unsigned>(checksum(std::span<const uint8_t>(frame).first(3))));
    std::printf("sizeof(std::span<const uint8_t>) = %zu: a pointer and a length\n", sizeof(std::span<const uint8_t>));
    std::printf("sizeof(std::span<const uint8_t, 4>) = %zu: the length is in the type\n",
                sizeof(std::span<const uint8_t, 4>));
    return 0;
}

// move.cpp - handing a DMA channel on, without copying it
#include <cstdio>
#include <utility>

static bool channel_in_use[4] = {false, false, false, false};

static int dma_claim() {
    for (int i = 0; i < 4; i++) {
        if (!channel_in_use[i]) {
            channel_in_use[i] = true;
            return i;
        }
    }
    return -1;
}

static void dma_release(int ch) {
    channel_in_use[ch] = false;
    std::printf("channel %d released\n", ch);
}

class DmaChannel {
public:
    DmaChannel() : ch_(dma_claim()) { std::printf("channel %d claimed\n", ch_); }
    ~DmaChannel() {
        if (ch_ >= 0) {
            dma_release(ch_);
        }
    }
    DmaChannel(const DmaChannel &) = delete;                // no copies, as in Volume 03
    DmaChannel &operator=(const DmaChannel &) = delete;

    // A move: take over the other object's channel, and leave it owning nothing.
    DmaChannel(DmaChannel &&other) : ch_(other.ch_) { other.ch_ = -1; }
    DmaChannel &operator=(DmaChannel &&other) {
        if (this != &other) {
            if (ch_ >= 0) {
                dma_release(ch_);
            }
            ch_ = other.ch_;
            other.ch_ = -1;
        }
        return *this;
    }
    int number() const { return ch_; }

private:
    int ch_;
};

class UartDriver {
public:
    explicit UartDriver(DmaChannel &&tx) : tx_(std::move(tx)) {}
    int tx_channel() const { return tx_.number(); }

private:
    DmaChannel tx_;
};

int main() {
    DmaChannel ch;
    std::printf("before the move: ch owns channel %d\n", ch.number());
    UartDriver uart(std::move(ch));
    std::printf("after the move: ch owns %d, the driver owns channel %d\n", ch.number(), uart.tx_channel());
    return 0;
}

// nodiscard.cpp - a status that is thrown away
#include <cstdint>

enum class Status : uint8_t { ok, timeout };

[[nodiscard]] Status uart_send(uint8_t byte);

void say_hello() {
    uart_send('H');
}

// nodiscard_type.cpp - [[nodiscard]] on the type: every function returning it is covered
#include <cstdint>

enum class [[nodiscard]] Status : uint8_t { ok, timeout };

Status uart_send(uint8_t byte);
Status spi_send(uint8_t byte);

void say_hello() {
    uart_send('H');
    spi_send('H');
}

// attributes.cpp - [[fallthrough]], [[maybe_unused]] and [[noreturn]], with every warning on
#include <cstdio>
#include <cstdlib>

[[noreturn]] static void fault(const char *why) {
    std::printf("fault: %s - stopping\n", why);
    std::exit(0);                       // on a chip: an endless loop, or a reset
}

static int divisor_for(int mode) {
    if (mode == 1) {
        return 104;
    }
    if (mode == 2) {
        return 52;
    }
    fault("unknown mode");              // never returns, so nothing is needed after it
}

static int steps_for(int mode) {
    int steps = 0;
    switch (mode) {
    case 2:
        steps += 10;
        [[fallthrough]];                // on purpose: mode 2 does mode 1's work as well
    case 1:
        steps += 1;
        break;
    default:
        break;
    }
    return steps;
}

static void log_value([[maybe_unused]] int value) {
    // A debug build would print the value here; this build does nothing with it.
}

int main() {
    std::printf("steps for mode 1: %d, for mode 2: %d\n", steps_for(1), steps_for(2));
    std::printf("divisor for mode 2: %d\n", divisor_for(2));
    log_value(5);
    std::printf("divisor for mode 3: %d\n", divisor_for(3));
    return 0;
}