card10-l0dable/src/framebuffer/mod.rs

+use crate::Display;
+use card10_sys::*;
+use core::mem::{transmute, uninitialized};
+use core::ops::{Index, IndexMut};
+
+use embedded_graphics::pixelcolor::{PixelColor, Rgb565};
+use embedded_graphics::prelude::Pixel;
+use embedded_graphics::Drawing;
+
+mod font;
+pub use font::*;
+mod text;
+pub use text::TextRenderer;
+
+pub struct FrameBuffer<'d> {
+    _display: &'d mut Display,
+    buffer: disp_framebuffer,
+}
+
+impl<'d> FrameBuffer<'d> {
+    pub fn uninitialized(display: &'d mut Display) -> Self {
+        FrameBuffer {
+            _display: display,
+            buffer: unsafe { uninitialized() },
+        }
+    }
+
+    pub fn send(&mut self) {
+        unsafe {
+            epic_disp_framebuffer(&mut self.buffer);
+        }
+    }
+
+    pub fn clear(&mut self, color: RawColor) {
+        for y in 0..Display::H {
+            for x in 0..Display::W {
+                let bytes: &mut RawColor =
+                    unsafe { transmute(&mut self.buffer.fb[y as usize][x as usize]) };
+                *bytes = color;
+            }
+        }
+    }
+
+    pub fn text<'a, 'f>(
+        &'a mut self,
+        x: isize,
+        y: isize,
+        font: &'f Font,
+        color: RawColor,
+    ) -> TextRenderer<'a, 'd, 'f> {
+        TextRenderer {
+            framebuffer: self,
+            x,
+            y,
+            font,
+            color,
+        }
+    }
+}
+
+impl<'d> Index<(u16, u16)> for FrameBuffer<'d> {
+    type Output = RawColor;
+    fn index(&self, (x, y): (u16, u16)) -> &Self::Output {
+        let x = usize::from(Display::W as u16 - 1 - x);
+        let y = usize::from(Display::H as u16 - 1 - y);
+        unsafe { transmute(&self.buffer.fb[y][x]) }
+    }
+}
+
+impl<'d> IndexMut<(u16, u16)> for FrameBuffer<'d> {
+    fn index_mut(&mut self, (x, y): (u16, u16)) -> &mut Self::Output {
+        let x = usize::from(Display::W as u16 - 1 - x);
+        let y = usize::from(Display::H as u16 - 1 - y);
+        unsafe { transmute(&mut self.buffer.fb[y][x]) }
+    }
+}
+
+/// `embedded-graphics` support
+impl<'d, C: PixelColor + Into<RawColor>> Drawing<C> for FrameBuffer<'d> {
+    fn draw<T>(&mut self, item: T)
+    where
+        T: IntoIterator<Item = Pixel<C>>,
+    {
+        for Pixel(coord, color) in item {
+            let x = coord[0] as u16;
+            let y = coord[1] as u16;
+
+            if x >= Display::W as u16 || y >= Display::H as u16 {
+                continue;
+            }
+            // Swap bytes
+            self[(x, y)] = color.into();
+        }
+    }
+}
+
+/// RGB565 with swapped bytes
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct RawColor([u8; 2]);
+
+impl RawColor {
+    pub fn red() -> Self {
+        Self::rgb8(0xff, 0, 0)
+    }
+
+    pub fn blue() -> Self {
+        Self::rgb8(0, 0, 0xff)
+    }
+
+    pub fn green() -> Self {
+        Self::rgb8(0, 0xff, 0)
+    }
+
+    pub fn black() -> Self {
+        Self::rgb8(0, 0, 0)
+    }
+
+    pub fn white() -> Self {
+        Self::rgb8(0xff, 0xff, 0xff)
+    }
+
+    pub fn yellow() -> Self {
+        Self::rgb8(0xff, 0xff, 0)
+    }
+
+    /// Construct from 0..255-triple
+    pub fn rgb8(r8: u8, g8: u8, b8: u8) -> Self {
+        let b1 = (r8 & 0xF8) | (g8 >> 5);
+        let b2 = ((g8 & 0xFA) << 3) | (b8 >> 3);
+        RawColor([b1, b2])
+    }
+
+    pub fn r8(&self) -> u8 {
+        self.0[0] & 0xF8
+    }
+
+    pub fn g8(&self) -> u8 {
+        ((self.0[0] & 0x7) << 5) |
+        ((self.0[0] & 0xE) >> 3)
+    }
+
+    pub fn b8(&self) -> u8 {
+        (self.0[1] & 0x1F) << 3
+    }
+}
+
+impl PixelColor for RawColor {}
+
+/// Most similar format, just byte-swapped
+impl From<Rgb565> for RawColor {
+    fn from(rgb: Rgb565) -> Self {
+        let c = rgb.0;
+        RawColor([(c >> 8) as u8, c as u8])
+    }
+}
+
+/// Dummy implementation required for impl Drawable
+impl From<u8> for RawColor {
+    fn from(b: u8) -> Self {
+        RawColor([0, b])
+    }
+}

card10-l0dable/src/framebuffer/text.rs

+use super::{Font, FrameBuffer, RawColor};
+use crate::Display;
+use core::fmt::Write;
+
+pub struct TextRenderer<'a, 'd, 'f> {
+    pub framebuffer: &'a mut FrameBuffer<'d>,
+    pub x: isize,
+    pub y: isize,
+    pub font: &'f Font,
+    pub color: RawColor,
+}
+
+impl<'a, 'd, 'f> Write for TextRenderer<'a, 'd, 'f> {
+    fn write_str(&mut self, s: &str) -> core::fmt::Result {
+        for c in s.chars() {
+            self.write_char(c)?;
+        }
+        Ok(())
+    }
+
+    fn write_char(&mut self, c: char) -> core::fmt::Result {
+        match self.font.get_glyph(c) {
+            None => Ok(()),
+            Some(glyph) => {
+                for y in 0..self.font.h {
+                    let y1 = (self.y + y as isize) as u16;
+                    if y1 < Display::H as u16 {
+                        for x in 0..self.font.w {
+                            let x1 = (self.x + x as isize) as u16;
+                            if x1 < Display::W as u16 {
+                                if glyph.get_pixel(x as usize, y as usize) {
+                                    self.framebuffer[(x1, y1)] = self.color;
+                                }
+                            }
+                        }
+                    }
+                }
+                self.x += self.font.w as isize;
+                Ok(())
+            }
+        }
+    }
+}

l0dable/src/fs.rs → card10-l0dable/src/fs.rs

-use core::str::from_utf8_unchecked;
+//! File System support (unfinished)
+
 use core::mem::uninitialized;
-use super::bindings::*;
+use core::str::from_utf8_unchecked;
+
+use card10_sys::*;
 
 type Result<T> = core::result::Result<T, Error>;
 
@@ -28,9 +31,7 @@ impl From<i32> for Error {
 
 pub fn read_dir(path: &str) -> Result<ReadDir> {
     let pathbuf = crate::str_to_cstr(path);
-    Error::check(|| unsafe {
-        epic_file_opendir(pathbuf.as_ptr())
-    }).map(|fd| ReadDir { fd })
+    Error::check(|| unsafe { epic_file_opendir(pathbuf.as_ptr()) }).map(|fd| ReadDir { fd })
 }
 
 pub struct ReadDir {
@@ -52,6 +53,7 @@ impl<'a> Iterator for ReadDir {
     }
 }
 
+#[allow(non_camel_case_types)]
 #[repr(u8)]
 #[derive(Copy, Clone)]
 pub enum epic_stat_type {
@@ -60,13 +62,14 @@ pub enum epic_stat_type {
     Dir = 2,
 }
 
+#[allow(non_camel_case_types)]
 #[repr(packed)]
 #[derive(Copy, Clone)]
 pub struct epic_stat {
     /// not u32 as generated by bindgen
     pub type_: epic_stat_type,
     pub size: u32,
-    pub name: [super::ctypes::c_char; 256usize],
+    pub name: [ctypes::c_char; 256usize],
     pub _reserved: [u8; 12usize],
 }
 
@@ -95,20 +98,15 @@ impl DirStat {
     }
 
     pub fn name(&self) -> &str {
-        let len = self.entry.name.iter().position(|b| *b == 0)
-            .unwrap_or(0);
-        unsafe {
-            from_utf8_unchecked(&self.entry.name[0..len])
-        }
+        let len = self.entry.name.iter().position(|b| *b == 0).unwrap_or(0);
+        unsafe { from_utf8_unchecked(&self.entry.name[0..len]) }
     }
 }
 
 pub fn rename(from: &str, to: &str) -> Result<()> {
     let frombuf = crate::str_to_cstr(from);
     let tobuf = crate::str_to_cstr(to);
-    Error::check(|| unsafe {
-        epic_file_rename(frombuf.as_ptr(), tobuf.as_ptr())
-    }).map(|_| ())
+    Error::check(|| unsafe { epic_file_rename(frombuf.as_ptr(), tobuf.as_ptr()) }).map(|_| ())
 }
 
 pub struct File {
@@ -119,21 +117,22 @@ impl File {
     pub fn open(path: &str) -> Result<File> {
         let pathbuf = crate::str_to_cstr(path);
         let modebuf = b"r\0";
-        Error::check(|| unsafe {
-            epic_file_open(pathbuf.as_ptr(), modebuf.as_ptr())
-        }).map(|fd| File { fd })
+        Error::check(|| unsafe { epic_file_open(pathbuf.as_ptr(), modebuf.as_ptr()) })
+            .map(|fd| File { fd })
     }
 
     pub fn read<'a>(&mut self, buf: &'a mut [u8]) -> Result<&'a [u8]> {
-        let bytes = Error::check(|| unsafe {
-            epic_file_read(self.fd, buf.as_ptr() as *mut _, buf.len())
-        })? as usize;
+        let bytes =
+            Error::check(|| unsafe { epic_file_read(self.fd, buf.as_ptr() as *mut _, buf.len()) })?
+                as usize;
         Ok(&buf[0..bytes])
     }
 }
 
 impl Drop for File {
     fn drop(&mut self) {
-        unsafe { epic_file_close(self.fd); }
+        unsafe {
+            epic_file_close(self.fd);
+        }
     }
 }

card10-l0dable/src/leds.rs

+//! Lights
+
+use card10_sys::*;
+
+#[derive(Clone, Copy)]
+pub enum LEDColor {
+    RGB(u8, u8, u8),
+    HSV(f32, f32, f32),
+}
+
+/// Update all RGB LEDs
+///
+/// `f` must supply a `LEDColor` for `0..=10`.
+pub fn update_rgb_leds<F>(f: F)
+where
+    F: Fn(i32) -> LEDColor,
+{
+    for index in 0..=10 {
+        let color = f(index);
+        match color {
+            LEDColor::RGB(r, g, b) => unsafe {
+                epic_leds_prep(index, r, g, b);
+            }
+            LEDColor::HSV(h, s, v) => unsafe {
+                epic_leds_prep_hsv(index, h, s, v);
+            }
+        }
+        unsafe {
+            epic_leds_update();
+        }
+    }
+}
+
+/// Set powersave mode for the RGB leds
+///
+/// Setting powersave mode disables the LEDs, saving
+/// ~15 mA
+pub fn set_rgb_leds_powersave(v: bool) {
+    unsafe { epic_leds_set_powersave(v); }
+}
+
+#[repr(i32)]
+pub enum Rocket {
+    Blue = 0,
+    Yellow = 1,
+    Green = 2,
+}
+
+/// Set one of the rocket LEDs to the desired brightness.
+///
+/// Brightness should be 0 - 31; larger values will be clamped.
+pub fn set_rocket(r: Rocket, brightness: u8) {
+    let v = if brightness > 31{31} else {brightness}; // clamp
+    unsafe { epic_leds_set_rocket(r as i32, v) }
+}

card10-l0dable/src/lib.rs

+//! [Repository](https://git.card10.badge.events.ccc.de/astro/rust-card10)
+#![no_std]
+
+mod os;
+pub use os::*;
+mod display;
+pub use display::{Color, Display, FillStyle, Font, LineStyle};
+mod buttons;
+pub mod framebuffer;
+pub use buttons::Buttons;
+pub mod uart;
+pub const UART: uart::Uart = uart::Uart;
+mod light_sensor;
+pub use light_sensor::LightSensor;
+mod rtc;
+pub mod trng;
+pub mod vibra;
+pub use rtc::{MilliSeconds, Seconds, Time};
+mod fmt_buffer;
+pub use fmt_buffer::{str_to_cstr, FmtBuffer};
+mod bme680;
+pub use bme680::BME680;
+mod max86150;
+pub use max86150::MAX86150;
+mod bhi160;
+pub use bhi160::{
+    Accelerometer, Error as BHI160Error, Gyroscope, Orientation, Sensor as BHI160,
+    SensorData as BHI160Data,
+};
+pub mod fs;
+mod leds;
+pub use leds::*;
+
+/// Type check the user-supplied entry function.
+#[macro_export]
+macro_rules! main {
+    ($path:path) => {
+        #[export_name = "main"]
+        pub unsafe fn __main() {
+            // type check the given path
+            let f: fn() = $path;
+
+            f()
+        }
+    };
+}

l0dable/src/light_sensor.rs → card10-l0dable/src/light_sensor.rs

-use super::bindings::*;
+use card10_sys::*;
 
-pub struct LightSensor;
+/// Light sensor
+pub struct LightSensor {
+    // Prevent creation of this struct by all but this module.
+    _private: (),
+}
 
 impl LightSensor {
+    /// Start sensing light
     pub fn start() -> Self {
         if unsafe { epic_light_sensor_run() } != 0 {
             panic!("Cannot start light sensor");
         }
-        LightSensor
+        LightSensor { _private: () }
     }
 
+    /// Obtain current light sensor reading
     pub fn get(&self) -> Option<u16> {
         let mut result = 0;
         if unsafe { epic_light_sensor_get(&mut result) } == 0 {
@@ -22,6 +28,8 @@ impl LightSensor {
 
 impl Drop for LightSensor {
     fn drop(&mut self) {
-        unsafe { epic_light_sensor_stop(); }
+        unsafe {
+            epic_light_sensor_stop();
+        }
     }
 }

card10-l0dable/src/max86150.rs

+// ECG and PPG sensor
+
+pub struct MAX86150 {
+    stream_id: i32,
+}
+
+use core::{mem::size_of, mem::MaybeUninit};
+
+use card10_sys::*;
+
+// TODO: redefine in common sensor
+use crate::bhi160::Error;
+
+const DATA_MAX: usize = 128;
+
+impl MAX86150 {
+    pub fn start() -> Result<Self, Error> {
+        let mut cfg = max86150_sensor_config {
+            sample_buffer_len: DATA_MAX,
+            ppg_sample_rate: 200,
+        };
+
+        let stream_id =
+            unsafe { epic_max86150_enable_sensor(&mut cfg, size_of::<max86150_sensor_config>()) };
+
+        if stream_id < 0 {
+            let error = match -stream_id {
+                errno::EBUSY => Error::DriverBusy,
+                _ => Error::Unknown(stream_id),
+            };
+
+            return Err(error);
+        }
+
+        Ok(MAX86150 { stream_id })
+    }
+
+    pub fn read(&self) -> Result<MAX86150SensorData, Error> {
+        let mut buffer = MaybeUninit::<[max86150_sensor_data; DATA_MAX]>::zeroed();
+        let buffer_pointer = buffer.as_mut_ptr() as *mut _;
+
+        let packet_count = unsafe {
+            epic_stream_read(
+                self.stream_id,
+                buffer_pointer,
+                size_of::<max86150_sensor_data>() * DATA_MAX,
+            )
+        };
+        if packet_count < 0 {
+            let error = match -packet_count {
+                errno::ENODEV => Error::SensorUnavailable,
+                errno::EBADF => Error::SensorDescriptorUnknown,
+                errno::EINVAL => Error::InvalidSampleCount,
+                errno::EBUSY => Error::CouldNotAcquireLock,
+                _ => Error::Unknown(packet_count),
+            };
+            return Err(error);
+        }
+
+        Ok(MAX86150SensorData {
+            buf: unsafe { buffer.assume_init() },
+            n: packet_count as usize,
+        })
+    }
+}
+
+pub struct MAX86150SensorData {
+    buf: [max86150_sensor_data; DATA_MAX],
+    n: usize,
+}
+
+impl MAX86150SensorData {
+    pub const fn is_empty(&self) -> bool {
+        self.n == 0
+    }
+
+    pub const fn len(&self) -> usize {
+        self.n
+    }
+}
+
+impl<'a> IntoIterator for &'a MAX86150SensorData {
+    type Item = MAX86150SensorDataItem;
+    type IntoIter = MAX86150SensorDataIterator<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        MAX86150SensorDataIterator { data: self, pos: 0 }
+    }
+}
+
+pub struct MAX86150SensorDataIterator<'a> {
+    data: &'a MAX86150SensorData,
+    pos: usize,
+}
+
+#[derive(Debug, Clone)]
+pub struct MAX86150SensorDataItem {
+    pub red_raw: u32,
+    pub ir_raw: u32,
+    pub ecg_raw: i32,
+}
+
+impl MAX86150SensorDataItem {
+    pub fn get_red(&self) -> u32 {
+        self.red_raw
+    }
+}
+
+impl<'a> Iterator for MAX86150SensorDataIterator<'a> {
+    type Item = MAX86150SensorDataItem;
+    fn next(&mut self) -> Option<Self::Item> {
+        while self.pos < self.data.n {
+            let vec = &self.data.buf[self.pos];
+            let item = MAX86150SensorDataItem {
+                red_raw: vec.red,
+                ir_raw: vec.ir,
+                ecg_raw: vec.ecg,
+            };
+
+            self.pos += 1;
+
+            return Some(item);
+        }
+        None
+    }
+}
+
+impl Drop for MAX86150 {
+    fn drop(&mut self) {
+        unsafe {
+            epic_max86150_disable_sensor();
+        }
+    }
+}

l0dable/src/os.rs → card10-l0dable/src/os.rs

-use super::bindings::*;
+use card10_sys::*;
 
+/// Execute Python script or ELF file
 pub fn exec(path: &str) -> ! {
     let mut pathbuf = super::str_to_cstr(path);
     unsafe {
@@ -8,16 +9,18 @@ pub fn exec(path: &str) -> ! {
     unreachable!()
 }
 
+/// Exit current l0dable
 pub fn exit(ret: i32) -> ! {
     unsafe {
         epic_exit(ret);
     }
-    unreachable!()
+    loop {}
 }
 
+/// Cause a reboot
 pub fn system_reset() -> ! {
     unsafe {
         epic_system_reset();
     }
-    unreachable!()
+    loop {}
 }

card10-l0dable/src/rtc.rs

+//! Real-time clock functionality
+
+use card10_sys::*;
+use core::ops::Sub;
+
+/// Implemented for `Seconds` and `Milliseconds`
+pub trait Time {
+    /// Get current time
+    fn time() -> Self;
+    /// Set the time (TODO)
+    fn set_time(&self);
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct Seconds(pub u32);
+
+impl From<MilliSeconds> for Seconds {
+    fn from(ms: MilliSeconds) -> Seconds {
+        Seconds((ms.0 / 1000) as u32)
+    }
+}
+
+impl Time for Seconds {
+    fn time() -> Self {
+        let s = unsafe { epic_rtc_get_seconds() };
+        Seconds(s)
+    }
+    /// TODO
+    fn set_time(&self) {
+    }
+}
+
+impl Sub for Seconds {
+    type Output = Seconds;
+    fn sub(self, rhs: Seconds) -> Self::Output {
+        Seconds(self.0 - rhs.0)
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct MilliSeconds(pub u64);
+
+impl From<Seconds> for MilliSeconds {
+    fn from(s: Seconds) -> MilliSeconds {
+        MilliSeconds(s.0 as u64 * 1000)
+    }
+}
+
+impl Time for MilliSeconds {
+    fn time() -> Self {
+        let ms = unsafe { epic_rtc_get_milliseconds() };
+        MilliSeconds(ms)
+    }
+    /// TODO
+    fn set_time(&self) {
+    }
+}
+
+impl Sub for MilliSeconds {
+    type Output = MilliSeconds;
+    fn sub(self, rhs: MilliSeconds) -> Self::Output {
+        MilliSeconds(self.0 - rhs.0)
+    }
+}

l0dable/src/trng.rs → card10-l0dable/src/trng.rs

-use super::bindings::*;
+//! True Random Number Generator
 
+use card10_sys::*;
+
+/// Read bytes from the True Random Number Generated
 pub fn read(dest: &mut [u8]) -> bool {
     unsafe { epic_trng_read(dest.as_mut_ptr(), dest.len()) != 0 }
 }

card10-l0dable/src/uart.rs

+use core::fmt::Write;
+
+use card10_sys::*;
+
+/// USB UART, 115200 baud
+///
+/// Supports use of `write!(Uart, "{}", ...);` Use `println!(...);`
+/// for convenience.
+pub struct Uart;
+
+impl Write for Uart {
+    fn write_str(&mut self, s: &str) -> core::fmt::Result {
+        unsafe {
+            epic_uart_write_str(s.as_ptr(), s.len());
+        }
+        Ok(())
+    }
+}
+
+#[macro_export]
+macro_rules! print {
+    ($($arg:tt)*) => ($crate::uart::_print(format_args!($($arg)*)));
+}
+
+#[macro_export]
+macro_rules! println {
+    () => ($crate::print!("\r"));
+    ($($arg:tt)*) => ($crate::print!("{}\r\n", format_args!($($arg)*)));
+}
+
+#[doc(hidden)]
+pub fn _print(args: core::fmt::Arguments) {
+    crate::UART.write_fmt(args).ok();
+}

card10-l0dable/src/vibra.rs

+//! Vibration motor
+
+use card10_sys::*;
+
+/// Set vibration motor to off/on
+pub fn set(status: bool) {
+    unsafe {
+        epic_vibra_set(status.into());
+    }
+}
+
+/// Vibrate for a duration
+pub fn vibrate(millis: i32) {
+    unsafe {
+        epic_vibra_vibrate(millis);
+    }
+}

card10-sys/Cargo.toml

+[package]
+
+name = "card10-sys"
+version = "1.10.0"
+authors = [
+    "Astro <astro@spaceboyz.net>",
+    "Kloenk <me@kloenk.de>",
+    "Bruno Kirschner <bruno.kirschner@online.de>",
+    "Puzzlewolf <camp@nora.pink>",
+    "Raphael Nestler <raphael.nestler@gmail.com>",
+    "Danilo Bargen <mail@dbrgn.ch>",
+    "toon <toon@c3d2.de>",
+    "Sergey Pepyakin <sergei@parity.io>",
+
+]
+license = "MIT/Apache-2.0"
+edition = "2018"
+
+description = "Unsafe C bindings for card10 l0dables"
+repository = "https://git.card10.badge.events.ccc.de/astro/rust-card10"
+homepage = "https://git.card10.badge.events.ccc.de/astro/rust-card10"
+documentation = "https://docs.rs/card10-sys"
+
+categories = ["external-ffi-bindings", "no-std"]
+keywords = [
+    "CCC",
+    "CCCamp2019",
+    "CCCamp19",
+    "card10",
+    "l0dable",
+]
+
+exclude = [
+    "target",
+    "firmware/lib/micropython",
+    "firmware/lib/ff13",
+    "firmware/lib/sdk/Documentation",
+    "firmware/lib/sdk/Applications",
+    "firmware/lib/sdk/Libraries/BTLE",
+    "firmware/lib/sdk/Libraries/FreeRTOS",
+    "firmware/lib/sdk/Libraries/FreeRTOS-Plus",
+    "firmware/lib/sdk/Libraries/SDHC",
+    "firmware/lib/sdk/Libraries/MAXUSB",
+    "firmware/openocd",
+    "firmware/Documentation",
+    "firmware/hw-tests",
+    "firmware/preload",
+    "firmware/pycardium",
+    "firmware/bootloader",
+    "firmware/tools",
+    "firmware/docker",
+]
+
+[dependencies]
+r0 = "^0.2"
+
+[build-dependencies]
+bindgen = "^0.52"
+cc = "^1.0"

card10-sys/build.rs

+use std::{env, error::Error, fs, path::PathBuf};
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let out = env::var_os("OUT_DIR")
+        .map(|path| PathBuf::from(path))
+        .ok_or("OUT_DIR definition missing")?;
+
+    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo:rerun-if-changed=vendor/l0dable.ld");
+    println!("cargo:rerun-if-changed=vendor/client.c");
+    println!("cargo:rerun-if-changed=vendor/wrapper.h");
+    println!("cargo:rustc-link-search={}", out.display());
+
+    // Linker script
+    fs::copy("vendor/crt.s", out.join("crt.s"))?;
+    fs::copy("vendor/l0dable.ld", out.join("l0dable.ld"))?;
+
+    // Link against C code
+    cc::Build::new()
+        .target("thumbv7em-none-eabi")
+        .compiler("arm-none-eabi-gcc")
+        .opt_level_str("s")
+        .debug(true)
+        .define("TARGET", "MAX32665")
+        .define("TARGET_UC", "MAX32665")
+        .define("TARGET_LC", "max32665")
+        .define("TARGET_REV", "0x4131")
+        .define("BOARD", "card10")
+        .flag("-fPIE")
+        .flag("-pie")
+        .include("firmware/epicardium")
+        .include("firmware/lib/sdk/Libraries/CMSIS/Device/Maxim/MAX32665/Include")
+        .include("firmware/lib/sdk/Libraries/CMSIS/Include")
+        .include("firmware/lib/sdk/Libraries/MAX32665PeriphDriver/Include")
+        .file("firmware/lib/sdk/Libraries/MAX32665PeriphDriver/Source/sema.c")
+        .file("firmware/lib/sdk/Libraries/MAX32665PeriphDriver/Source/mxc_assert.c")
+        .file("firmware/l0dables/lib/hardware.c")
+        .file("firmware/epicardium/api/caller.c")
+        .file("firmware/lib/gfx/Fonts/font12.c")
+        .file("firmware/lib/gfx/Fonts/font16.c")
+        .file("firmware/lib/gfx/Fonts/font20.c")
+        .file("firmware/lib/gfx/Fonts/font24.c")
+        .file("firmware/lib/gfx/Fonts/font8.c")
+        .file("vendor/client.c")
+        .compile("card10");
+
+    // Generate bindings to C code
+    let bindings = bindgen::Builder::default()
+        .use_core()
+        .clang_arg("-Isrc")
+        .clang_arg("-Ifirmware/epicardium")
+        .clang_arg("-Ifirmware/lib/sdk/Libraries/CMSIS/Device/Maxim/MAX32665/Include")
+        .clang_arg("-Ifirmware/lib/sdk/Libraries/CMSIS/Include")
+        .clang_arg("-Ifirmware/lib/sdk/Libraries/MAX32665PeriphDriver/Include")
+        .header("vendor/wrapper.h")
+        .ctypes_prefix("ctypes")
+        .opaque_type("epic_stat")
+        .generate()
+        .map_err(|_| "Couldn't generate bindings")?;
+
+    bindings.write_to_file(out.join("bindings.rs"))?;
+
+    Ok(())
+}

firmware @ da4bc11f

+Subproject commit da4bc11fbdded3588a97b1f905da4866a30f520c

card10-sys/src/lib.rs

+//! This gets linked with the client C code for the card10 EPIC API.
+
+#![no_std]
+#![feature(global_asm)]
+#![allow(non_camel_case_types)]
+#![allow(non_upper_case_globals)]
+#![allow(non_snake_case)]
+#![feature(core_intrinsics)]
+#![feature(panic_info_message)]
+
+use core::fmt::Write;
+use core::intrinsics;
+use core::panic::PanicInfo;
+
+pub struct Uart;
+
+impl Write for Uart {
+    fn write_str(&mut self, s: &str) -> core::fmt::Result {
+        unsafe {
+            epic_uart_write_str(s.as_ptr(), s.len());
+        }
+        Ok(())
+    }
+}
+
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    write!(Uart, "panicked").ok();
+
+    if let Some(message) = info.message() {
+        write!(Uart, " at '{}'", message).ok();
+    }
+
+    if let Some(location) = info.location() {
+        write!(
+            Uart,
+            ", {}:{}:{}",
+            location.file(),
+            location.line(),
+            location.column()
+        )
+        .ok();
+    }
+    writeln!(Uart, "\r").ok();
+    unsafe { intrinsics::abort() }
+}
+
+global_asm!(include_str!(concat!(env!("OUT_DIR"), "/crt.s")));
+include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
+
+/// Initialization for l0dables
+#[link_section = ".text.boot"]
+#[no_mangle]
+pub unsafe extern "C" fn Reset_Handler() -> ! {
+    extern "C" {
+        fn SystemInit();
+        // Boundaries of the .bss section, provided by the linker script
+        static mut __bss_start: u32;
+        static mut __bss_end: u32;
+    }
+
+    // Zeroes the .bss section
+    r0::zero_bss(&mut __bss_start, &mut __bss_end);
+    SystemInit();
+
+    extern "Rust" {
+        fn main();
+    }
+
+    main();
+
+    epic_exit(0);
+    unreachable!()
+}
+
+pub mod ctypes {
+    pub type c_short = i16;
+    pub type c_ushort = u16;
+    pub type c_int = i32;
+    pub type c_uint = u32;
+    pub type c_long = i32;
+    pub type c_ulong = u32;
+    pub type c_longlong = i64;
+    pub type c_ulonglong = u64;
+    pub type c_char = u8;
+    pub type c_schar = i8;
+    pub type c_uchar = u8;
+    pub use core::ffi::c_void;
+}
+
+pub mod errno {
+    use crate::ctypes::c_int;
+
+    pub const EPERM: c_int = 1; // Operation not permitted
+    pub const ENOENT: c_int = 2; // No such file or directory
+    pub const ESRCH: c_int = 3; // No such process
+    pub const EINTR: c_int = 4; // Interrupted system call
+    pub const EIO: c_int = 5; // I/O error
+    pub const ENXIO: c_int = 6; // No such device or address
+    pub const E2BIG: c_int = 7; // Argument list too long
+    pub const ENOEXEC: c_int = 8; // Exec format error
+    pub const EBADF: c_int = 9; // Bad file number
+    pub const ECHILD: c_int = 10; // No child processes
+    pub const EAGAIN: c_int = 11; // Try again
+    pub const ENOMEM: c_int = 12; //Out of memory
+    pub const EACCES: c_int = 13; //Permission denied
+    pub const EFAULT: c_int = 14; //Bad address
+    pub const ENOTBLK: c_int = 15; //Block device required
+    pub const EBUSY: c_int = 16; //Device or resource busy
+    pub const EEXIST: c_int = 17; //File exists
+    pub const EXDEV: c_int = 18; //Cross-device link
+    pub const ENODEV: c_int = 19; //No such device
+    pub const ENOTDIR: c_int = 20; //Not a directory
+    pub const EISDIR: c_int = 21; //Is a directory
+    pub const EINVAL: c_int = 22; //Invalid argument
+    pub const ENFILE: c_int = 23; //File table overflow
+    pub const EMFILE: c_int = 24; //Too many open files
+    pub const ENOTTY: c_int = 25; //Not a typewriter
+    pub const ETXTBSY: c_int = 26; //Text file busy
+    pub const EFBIG: c_int = 27; //File too large
+    pub const ENOSPC: c_int = 28; //No space left on device
+    pub const ESPIPE: c_int = 29; //Illegal seek
+    pub const EROFS: c_int = 30; //Read-only file system
+    pub const EMLINK: c_int = 31; //Too many links
+    pub const EPIPE: c_int = 32; //Broken pipe
+    pub const EDOM: c_int = 33; //Math argument out of domain of func
+    pub const ERANGE: c_int = 34; //Math result not representable
+    pub const EAFNOSUPPORT: c_int = 97; //Address family not supported by protocol
+    pub const ECONNRESET: c_int = 104; //Connection timed out
+    pub const ETIMEDOUT: c_int = 110; //Connection timed out
+    pub const EINPROGRESS: c_int = 115; //Operation now in progress
+}

l0dable/src/client.c → card10-sys/vendor/client.c

@@ -158,16 +158,16 @@ int epic_read_thermistor_voltage(float *result)
 }
 
 /* Autogenerated stub for API_UART_WRITE_STR */
-void epic_uart_write_str( const char *str, intptr_t length )
+void epic_uart_write_str( const char *str, size_t length)
 {
-        const int epc__apistub_size = sizeof(const char *) + sizeof(intptr_t);
+        const int epc__apistub_size = sizeof(const char *) + sizeof(size_t);
         void*epc__apistub_buffer;
 
         epc__apistub_buffer = _api_call_start(API_UART_WRITE_STR, epc__apistub_size);
         /* TODO: Check if epc__apistub_buffer is not NULL */
 
         *(const char **)(epc__apistub_buffer + 0) = str;
-        *(intptr_t*)(epc__apistub_buffer + sizeof(const char *)) = length;
+        *(size_t*)(epc__apistub_buffer + sizeof(const char *)) = length;
 
         _api_call_transact(epc__apistub_buffer);
 }
@@ -259,7 +259,7 @@ int epic_gpio_write_pin(uint8_t pin, _Bool on)
 }
 
 /* Autogenerated stub for API_GPIO_READ_PIN */
-uint32_t epic_gpio_read_pin(uint8_t pin)
+int epic_gpio_read_pin(uint8_t pin)
 {
         const int epc__apistub_size = sizeof(uint8_t);
         void*epc__apistub_buffer;
@@ -269,7 +269,7 @@ uint32_t epic_gpio_read_pin(uint8_t pin)
 
         *(uint8_t*)(epc__apistub_buffer + 0) = pin;
 
-        return *(uint32_t*)_api_call_transact(epc__apistub_buffer);
+        return *(int*)_api_call_transact(epc__apistub_buffer);
 }
 
 /* Autogenerated stub for API_LEDS_SET */
@@ -289,6 +289,21 @@ void epic_leds_set(int led, uint8_t r, uint8_t g, uint8_t b)
         _api_call_transact(epc__apistub_buffer);
 }
 
+/* Autogenerated stub for API_LEDS_GET */
+int epic_leds_get_rgb(int led, uint8_t * rgb)
+{
+        const int epc__apistub_size = sizeof(int) + sizeof(uint8_t *);
+        void*epc__apistub_buffer;
+
+        epc__apistub_buffer = _api_call_start(API_LEDS_GET, epc__apistub_size);
+        /* TODO: Check if epc__apistub_buffer is not NULL */
+
+        *(int*)(epc__apistub_buffer + 0) = led;
+        *(uint8_t **)(epc__apistub_buffer + sizeof(int)) = rgb;
+
+        return *(int*)_api_call_transact(epc__apistub_buffer);
+}
+
 /* Autogenerated stub for API_LEDS_SET_HSV */
 void epic_leds_set_hsv( int led, float h, float s, float v)
 {
@@ -440,6 +455,20 @@ void epic_leds_set_rocket(int led, uint8_t value)
         _api_call_transact(epc__apistub_buffer);
 }
 
+/* Autogenerated stub for API_LEDS_GET_ROCKET */
+int epic_leds_get_rocket(int led)
+{
+        const int epc__apistub_size = sizeof(int);
+        void*epc__apistub_buffer;
+
+        epc__apistub_buffer = _api_call_start(API_LEDS_GET_ROCKET, epc__apistub_size);
+        /* TODO: Check if epc__apistub_buffer is not NULL */
+
+        *(int*)(epc__apistub_buffer + 0) = led;
+
+        return *(int*)_api_call_transact(epc__apistub_buffer);
+}
+
 /* Autogenerated stub for API_LEDS_SET_FLASHLIGHT */
 void epic_set_flashlight(_Bool power)
 {
@@ -525,6 +554,34 @@ int epic_bme680_read_sensors(struct bme680_sensor_data *data)
         return *(int*)_api_call_transact(epc__apistub_buffer);
 }
 
+/* Autogenerated stub for API_MAX86150_ENABLE */
+int epic_max86150_enable_sensor(struct max86150_sensor_config *config, size_t config_size)
+{
+        const int epc__apistub_size = sizeof(struct max86150_sensor_config *) + sizeof(size_t);
+        void*epc__apistub_buffer;
+
+        epc__apistub_buffer = _api_call_start(API_MAX86150_ENABLE, epc__apistub_size);
+        /* TODO: Check if epc__apistub_buffer is not NULL */
+
+        *(struct max86150_sensor_config **)(epc__apistub_buffer + 0) = config;
+        *(size_t*)(epc__apistub_buffer + sizeof(struct max86150_sensor_config *)) = config_size;
+
+        return *(int*)_api_call_transact(epc__apistub_buffer);
+}
+
+/* Autogenerated stub for API_MAX86150_DISABLE */
+int epic_max86150_disable_sensor()
+{
+        const int epc__apistub_size = 0;
+        void*epc__apistub_buffer;
+
+        epc__apistub_buffer = _api_call_start(API_MAX86150_DISABLE, epc__apistub_size);
+        /* TODO: Check if epc__apistub_buffer is not NULL */
+
+
+        return *(int*)_api_call_transact(epc__apistub_buffer);
+}
+
 /* Autogenerated stub for API_PERSONAL_STATE_SET */
 int epic_personal_state_set( uint8_t state, _Bool persistent)
 {
@@ -692,19 +749,38 @@ int epic_disp_update()
 }
 
 /* Autogenerated stub for API_DISP_PRINT */
-int epic_disp_print( uint16_t posx, uint16_t posy, const char *pString, uint16_t fg, uint16_t bg)
+int epic_disp_print( int16_t posx, int16_t posy, const char *pString, uint16_t fg, uint16_t bg)
 {
-        const int epc__apistub_size = sizeof(uint16_t) + sizeof(uint16_t) + sizeof(const char *) + sizeof(uint16_t) + sizeof(uint16_t);
+        const int epc__apistub_size = sizeof(int16_t) + sizeof(int16_t) + sizeof(const char *) + sizeof(uint16_t) + sizeof(uint16_t);
         void*epc__apistub_buffer;
 
         epc__apistub_buffer = _api_call_start(API_DISP_PRINT, epc__apistub_size);
         /* TODO: Check if epc__apistub_buffer is not NULL */
 
-        *(uint16_t*)(epc__apistub_buffer + 0) = posx;
-        *(uint16_t*)(epc__apistub_buffer + sizeof(uint16_t)) = posy;
-        *(const char **)(epc__apistub_buffer + sizeof(uint16_t) + sizeof(uint16_t)) = pString;
-        *(uint16_t*)(epc__apistub_buffer + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(const char *)) = fg;
-        *(uint16_t*)(epc__apistub_buffer + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(const char *) + sizeof(uint16_t)) = bg;
+        *(int16_t*)(epc__apistub_buffer + 0) = posx;
+        *(int16_t*)(epc__apistub_buffer + sizeof(int16_t)) = posy;
+        *(const char **)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t)) = pString;
+        *(uint16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(const char *)) = fg;
+        *(uint16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(const char *) + sizeof(uint16_t)) = bg;
+
+        return *(int*)_api_call_transact(epc__apistub_buffer);
+}
+
+/* Autogenerated stub for API_DISP_PRINT_ADV */
+int epic_disp_print_adv( uint8_t font, int16_t posx, int16_t posy, const char *pString, uint16_t fg, uint16_t bg)
+{
+        const int epc__apistub_size = sizeof(uint8_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(const char *) + sizeof(uint16_t) + sizeof(uint16_t);
+        void*epc__apistub_buffer;
+
+        epc__apistub_buffer = _api_call_start(API_DISP_PRINT_ADV, epc__apistub_size);
+        /* TODO: Check if epc__apistub_buffer is not NULL */
+
+        *(uint8_t*)(epc__apistub_buffer + 0) = font;
+        *(int16_t*)(epc__apistub_buffer + sizeof(uint8_t)) = posx;
+        *(int16_t*)(epc__apistub_buffer + sizeof(uint8_t) + sizeof(int16_t)) = posy;
+        *(const char **)(epc__apistub_buffer + sizeof(uint8_t) + sizeof(int16_t) + sizeof(int16_t)) = pString;
+        *(uint16_t*)(epc__apistub_buffer + sizeof(uint8_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(const char *)) = fg;
+        *(uint16_t*)(epc__apistub_buffer + sizeof(uint8_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(const char *) + sizeof(uint16_t)) = bg;
 
         return *(int*)_api_call_transact(epc__apistub_buffer);
 }
@@ -724,76 +800,76 @@ int epic_disp_clear(uint16_t color)
 }
 
 /* Autogenerated stub for API_DISP_PIXEL */
-int epic_disp_pixel( uint16_t x, uint16_t y, uint16_t color)
+int epic_disp_pixel( int16_t x, int16_t y, uint16_t color)
 {
-        const int epc__apistub_size = sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t);
+        const int epc__apistub_size = sizeof(int16_t) + sizeof(int16_t) + sizeof(uint16_t);
         void*epc__apistub_buffer;
 
         epc__apistub_buffer = _api_call_start(API_DISP_PIXEL, epc__apistub_size);
         /* TODO: Check if epc__apistub_buffer is not NULL */
 
-        *(uint16_t*)(epc__apistub_buffer + 0) = x;
-        *(uint16_t*)(epc__apistub_buffer + sizeof(uint16_t)) = y;
-        *(uint16_t*)(epc__apistub_buffer + sizeof(uint16_t) + sizeof(uint16_t)) = color;
+        *(int16_t*)(epc__apistub_buffer + 0) = x;
+        *(int16_t*)(epc__apistub_buffer + sizeof(int16_t)) = y;
+        *(uint16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t)) = color;
 
         return *(int*)_api_call_transact(epc__apistub_buffer);
 }
 
 /* Autogenerated stub for API_DISP_LINE */
-int epic_disp_line( uint16_t xstart, uint16_t ystart, uint16_t xend, uint16_t yend, uint16_t color, enum disp_linestyle linestyle, uint16_t pixelsize)
+int epic_disp_line( int16_t xstart, int16_t ystart, int16_t xend, int16_t yend, uint16_t color, enum disp_linestyle linestyle, uint16_t pixelsize)
 {
-        const int epc__apistub_size = sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(enum disp_linestyle) + sizeof(uint16_t);
+        const int epc__apistub_size = sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(uint16_t) + sizeof(enum disp_linestyle) + sizeof(uint16_t);
         void*epc__apistub_buffer;
 
         epc__apistub_buffer = _api_call_start(API_DISP_LINE, epc__apistub_size);
         /* TODO: Check if epc__apistub_buffer is not NULL */
 
-        *(uint16_t*)(epc__apistub_buffer + 0) = xstart;
-        *(uint16_t*)(epc__apistub_buffer + sizeof(uint16_t)) = ystart;
-        *(uint16_t*)(epc__apistub_buffer + sizeof(uint16_t) + sizeof(uint16_t)) = xend;
-        *(uint16_t*)(epc__apistub_buffer + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t)) = yend;
-        *(uint16_t*)(epc__apistub_buffer + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t)) = color;
-        *(enum disp_linestyle*)(epc__apistub_buffer + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t)) = linestyle;
-        *(uint16_t*)(epc__apistub_buffer + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(enum disp_linestyle)) = pixelsize;
+        *(int16_t*)(epc__apistub_buffer + 0) = xstart;
+        *(int16_t*)(epc__apistub_buffer + sizeof(int16_t)) = ystart;
+        *(int16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t)) = xend;
+        *(int16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t)) = yend;
+        *(uint16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t)) = color;
+        *(enum disp_linestyle*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(uint16_t)) = linestyle;
+        *(uint16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(uint16_t) + sizeof(enum disp_linestyle)) = pixelsize;
 
         return *(int*)_api_call_transact(epc__apistub_buffer);
 }
 
 /* Autogenerated stub for API_DISP_RECT */
-int epic_disp_rect( uint16_t xstart, uint16_t ystart, uint16_t xend, uint16_t yend, uint16_t color, enum disp_fillstyle fillstyle, uint16_t pixelsize)
+int epic_disp_rect( int16_t xstart, int16_t ystart, int16_t xend, int16_t yend, uint16_t color, enum disp_fillstyle fillstyle, uint16_t pixelsize)
 {
-        const int epc__apistub_size = sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(enum disp_fillstyle) + sizeof(uint16_t);
+        const int epc__apistub_size = sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(uint16_t) + sizeof(enum disp_fillstyle) + sizeof(uint16_t);
         void*epc__apistub_buffer;
 
         epc__apistub_buffer = _api_call_start(API_DISP_RECT, epc__apistub_size);
         /* TODO: Check if epc__apistub_buffer is not NULL */
 
-        *(uint16_t*)(epc__apistub_buffer + 0) = xstart;
-        *(uint16_t*)(epc__apistub_buffer + sizeof(uint16_t)) = ystart;
-        *(uint16_t*)(epc__apistub_buffer + sizeof(uint16_t) + sizeof(uint16_t)) = xend;
-        *(uint16_t*)(epc__apistub_buffer + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t)) = yend;
-        *(uint16_t*)(epc__apistub_buffer + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t)) = color;
-        *(enum disp_fillstyle*)(epc__apistub_buffer + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t)) = fillstyle;
-        *(uint16_t*)(epc__apistub_buffer + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(enum disp_fillstyle)) = pixelsize;
+        *(int16_t*)(epc__apistub_buffer + 0) = xstart;
+        *(int16_t*)(epc__apistub_buffer + sizeof(int16_t)) = ystart;
+        *(int16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t)) = xend;
+        *(int16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t)) = yend;
+        *(uint16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t)) = color;
+        *(enum disp_fillstyle*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(uint16_t)) = fillstyle;
+        *(uint16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(uint16_t) + sizeof(enum disp_fillstyle)) = pixelsize;
 
         return *(int*)_api_call_transact(epc__apistub_buffer);
 }
 
 /* Autogenerated stub for API_DISP_CIRC */
-int epic_disp_circ( uint16_t x, uint16_t y, uint16_t rad, uint16_t color, enum disp_fillstyle fillstyle, uint16_t pixelsize)
+int epic_disp_circ( int16_t x, int16_t y, uint16_t rad, uint16_t color, enum disp_fillstyle fillstyle, uint16_t pixelsize)
 {
-        const int epc__apistub_size = sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(enum disp_fillstyle) + sizeof(uint16_t);
+        const int epc__apistub_size = sizeof(int16_t) + sizeof(int16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(enum disp_fillstyle) + sizeof(uint16_t);
         void*epc__apistub_buffer;
 
         epc__apistub_buffer = _api_call_start(API_DISP_CIRC, epc__apistub_size);
         /* TODO: Check if epc__apistub_buffer is not NULL */
 
-        *(uint16_t*)(epc__apistub_buffer + 0) = x;
-        *(uint16_t*)(epc__apistub_buffer + sizeof(uint16_t)) = y;
-        *(uint16_t*)(epc__apistub_buffer + sizeof(uint16_t) + sizeof(uint16_t)) = rad;
-        *(uint16_t*)(epc__apistub_buffer + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t)) = color;
-        *(enum disp_fillstyle*)(epc__apistub_buffer + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t)) = fillstyle;
-        *(uint16_t*)(epc__apistub_buffer + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(enum disp_fillstyle)) = pixelsize;
+        *(int16_t*)(epc__apistub_buffer + 0) = x;
+        *(int16_t*)(epc__apistub_buffer + sizeof(int16_t)) = y;
+        *(uint16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t)) = rad;
+        *(uint16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(uint16_t)) = color;
+        *(enum disp_fillstyle*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(uint16_t) + sizeof(uint16_t)) = fillstyle;
+        *(uint16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(enum disp_fillstyle)) = pixelsize;
 
         return *(int*)_api_call_transact(epc__apistub_buffer);
 }
@@ -812,6 +888,20 @@ int epic_disp_framebuffer(union disp_framebuffer *fb)
         return *(int*)_api_call_transact(epc__apistub_buffer);
 }
 
+/* Autogenerated stub for API_DISP_BACKLIGHT */
+int epic_disp_backlight(uint16_t brightness)
+{
+        const int epc__apistub_size = sizeof(uint16_t);
+        void*epc__apistub_buffer;
+
+        epc__apistub_buffer = _api_call_start(API_DISP_BACKLIGHT, epc__apistub_size);
+        /* TODO: Check if epc__apistub_buffer is not NULL */
+
+        *(uint16_t*)(epc__apistub_buffer + 0) = brightness;
+
+        return *(int*)_api_call_transact(epc__apistub_buffer);
+}
+
 /* Autogenerated stub for API_LIGHT_SENSOR_RUN */
 int epic_light_sensor_run()
 {
@@ -852,6 +942,19 @@ int epic_light_sensor_stop()
         return *(int*)_api_call_transact(epc__apistub_buffer);
 }
 
+/* Autogenerated stub for API_LIGHT_SENSOR_READ */
+uint16_t epic_light_sensor_read(void)
+{
+        const int epc__apistub_size = 0;
+        void*epc__apistub_buffer;
+
+        epc__apistub_buffer = _api_call_start(API_LIGHT_SENSOR_READ, epc__apistub_size);
+        /* TODO: Check if epc__apistub_buffer is not NULL */
+
+
+        return *(uint16_t*)_api_call_transact(epc__apistub_buffer);
+}
+
 /* Autogenerated stub for API_FILE_OPEN */
 int epic_file_open( const char* filename, const char* modeString)
 {
@@ -1044,6 +1147,32 @@ int epic_file_mkdir(const char *dirname)
         return *(int*)_api_call_transact(epc__apistub_buffer);
 }
 
+/* Autogenerated stub for API_RTC_GET_MONOTONIC_SECONDS */
+uint32_t epic_rtc_get_monotonic_seconds(void)
+{
+        const int epc__apistub_size = 0;
+        void*epc__apistub_buffer;
+
+        epc__apistub_buffer = _api_call_start(API_RTC_GET_MONOTONIC_SECONDS, epc__apistub_size);
+        /* TODO: Check if epc__apistub_buffer is not NULL */
+
+
+        return *(uint32_t*)_api_call_transact(epc__apistub_buffer);
+}
+
+/* Autogenerated stub for API_RTC_GET_MONOTONIC_MILLISECONDS */
+uint64_t epic_rtc_get_monotonic_milliseconds(void)
+{
+        const int epc__apistub_size = 0;
+        void*epc__apistub_buffer;
+
+        epc__apistub_buffer = _api_call_start(API_RTC_GET_MONOTONIC_MILLISECONDS, epc__apistub_size);
+        /* TODO: Check if epc__apistub_buffer is not NULL */
+
+
+        return *(uint64_t*)_api_call_transact(epc__apistub_buffer);
+}
+
 /* Autogenerated stub for API_RTC_GET_SECONDS */
 uint32_t epic_rtc_get_seconds(void)
 {
@@ -1057,6 +1186,19 @@ uint32_t epic_rtc_get_seconds(void)
         return *(uint32_t*)_api_call_transact(epc__apistub_buffer);
 }
 
+/* Autogenerated stub for API_RTC_GET_MILLISECONDS */
+uint64_t epic_rtc_get_milliseconds(void)
+{
+        const int epc__apistub_size = 0;
+        void*epc__apistub_buffer;
+
+        epc__apistub_buffer = _api_call_start(API_RTC_GET_MILLISECONDS, epc__apistub_size);
+        /* TODO: Check if epc__apistub_buffer is not NULL */
+
+
+        return *(uint64_t*)_api_call_transact(epc__apistub_buffer);
+}
+
 /* Autogenerated stub for API_RTC_SET_MILLISECONDS */
 void epic_rtc_set_milliseconds( uint64_t milliseconds)
 {
@@ -1100,22 +1242,156 @@ int epic_trng_read(uint8_t *dest, size_t size)
         return *(int*)_api_call_transact(epc__apistub_buffer);
 }
 
+/* Autogenerated stub for API_MAX30001_ENABLE */
+int epic_max30001_enable_sensor( struct max30001_sensor_config *config)
+{
+        const int epc__apistub_size = sizeof(struct max30001_sensor_config *);
+        void*epc__apistub_buffer;
+
+        epc__apistub_buffer = _api_call_start(API_MAX30001_ENABLE, epc__apistub_size);
+        /* TODO: Check if epc__apistub_buffer is not NULL */
+
+        *(struct max30001_sensor_config **)(epc__apistub_buffer + 0) = config;
+
+        return *(int*)_api_call_transact(epc__apistub_buffer);
+}
+
+/* Autogenerated stub for API_MAX30001_DISABLE */
+int epic_max30001_disable_sensor()
+{
+        const int epc__apistub_size = 0;
+        void*epc__apistub_buffer;
+
+        epc__apistub_buffer = _api_call_start(API_MAX30001_DISABLE, epc__apistub_size);
+        /* TODO: Check if epc__apistub_buffer is not NULL */
+
+
+        return *(int*)_api_call_transact(epc__apistub_buffer);
+}
+
+/* Autogenerated stub for API_USB_SHUTDOWN */
+int epic_usb_shutdown(void)
+{
+        const int epc__apistub_size = 0;
+        void*epc__apistub_buffer;
+
+        epc__apistub_buffer = _api_call_start(API_USB_SHUTDOWN, epc__apistub_size);
+        /* TODO: Check if epc__apistub_buffer is not NULL */
+
+
+        return *(int*)_api_call_transact(epc__apistub_buffer);
+}
+
+/* Autogenerated stub for API_USB_STORAGE */
+int epic_usb_storage(void)
+{
+        const int epc__apistub_size = 0;
+        void*epc__apistub_buffer;
+
+        epc__apistub_buffer = _api_call_start(API_USB_STORAGE, epc__apistub_size);
+        /* TODO: Check if epc__apistub_buffer is not NULL */
+
+
+        return *(int*)_api_call_transact(epc__apistub_buffer);
+}
+
+/* Autogenerated stub for API_USB_CDCACM */
+int epic_usb_cdcacm(void)
+{
+        const int epc__apistub_size = 0;
+        void*epc__apistub_buffer;
+
+        epc__apistub_buffer = _api_call_start(API_USB_CDCACM, epc__apistub_size);
+        /* TODO: Check if epc__apistub_buffer is not NULL */
+
+
+        return *(int*)_api_call_transact(epc__apistub_buffer);
+}
+
+/* Autogenerated stub for API_WS2812_WRITE */
+void epic_ws2812_write(uint8_t pin, uint8_t *pixels, uint32_t n_bytes)
+{
+        const int epc__apistub_size = sizeof(uint8_t) + sizeof(uint8_t *) + sizeof(uint32_t);
+        void*epc__apistub_buffer;
+
+        epc__apistub_buffer = _api_call_start(API_WS2812_WRITE, epc__apistub_size);
+        /* TODO: Check if epc__apistub_buffer is not NULL */
+
+        *(uint8_t*)(epc__apistub_buffer + 0) = pin;
+        *(uint8_t **)(epc__apistub_buffer + sizeof(uint8_t)) = pixels;
+        *(uint32_t*)(epc__apistub_buffer + sizeof(uint8_t) + sizeof(uint8_t *)) = n_bytes;
+
+        _api_call_transact(epc__apistub_buffer);
+}
+
+/* Autogenerated stub for API_CONFIG_GET_INTEGER */
+int epic_config_get_integer(const char *key, int *value)
+{
+        const int epc__apistub_size = sizeof(const char *) + sizeof(int *);
+        void*epc__apistub_buffer;
+
+        epc__apistub_buffer = _api_call_start(API_CONFIG_GET_INTEGER, epc__apistub_size);
+        /* TODO: Check if epc__apistub_buffer is not NULL */
+
+        *(const char **)(epc__apistub_buffer + 0) = key;
+        *(int **)(epc__apistub_buffer + sizeof(const char *)) = value;
+
+        return *(int*)_api_call_transact(epc__apistub_buffer);
+}
+
+/* Autogenerated stub for API_CONFIG_GET_BOOLEAN */
+int epic_config_get_boolean(const char *key, _Bool *value)
+{
+        const int epc__apistub_size = sizeof(const char *) + sizeof(_Bool *);
+        void*epc__apistub_buffer;
+
+        epc__apistub_buffer = _api_call_start(API_CONFIG_GET_BOOLEAN, epc__apistub_size);
+        /* TODO: Check if epc__apistub_buffer is not NULL */
+
+        *(const char **)(epc__apistub_buffer + 0) = key;
+        *(_Bool **)(epc__apistub_buffer + sizeof(const char *)) = value;
+
+        return *(int*)_api_call_transact(epc__apistub_buffer);
+}
+
+/* Autogenerated stub for API_CONFIG_GET_STRING */
+int epic_config_get_string(const char *key, char *buf, size_t buf_len)
+{
+        const int epc__apistub_size = sizeof(const char *) + sizeof(char *) + sizeof(size_t);
+        void*epc__apistub_buffer;
+
+        epc__apistub_buffer = _api_call_start(API_CONFIG_GET_STRING, epc__apistub_size);
+        /* TODO: Check if epc__apistub_buffer is not NULL */
+
+        *(const char **)(epc__apistub_buffer + 0) = key;
+        *(char **)(epc__apistub_buffer + sizeof(const char *)) = buf;
+        *(size_t*)(epc__apistub_buffer + sizeof(const char *) + sizeof(char *)) = buf_len;
+
+        return *(int*)_api_call_transact(epc__apistub_buffer);
+}
+
 
 /* Weakly linked stubs for ISRs */
-void epic_isr_bhi160_accelerometer(api_int_id_t id)
-        __attribute__((weak, alias("__epic_isr_default_handler")));
-void epic_isr_bhi160_orientation(api_int_id_t id)
-        __attribute__((weak, alias("__epic_isr_default_handler")));
-void epic_isr_bhi160_gyroscope(api_int_id_t id)
-        __attribute__((weak, alias("__epic_isr_default_handler")));
 void __epic_isr_reset(api_int_id_t id)
         __attribute__((weak, alias("__epic_isr_default_handler")));
 void epic_isr_uart_rx(api_int_id_t id)
         __attribute__((weak, alias("__epic_isr_default_handler")));
 void epic_isr_ctrl_c(api_int_id_t id)
         __attribute__((weak, alias("__epic_isr_default_handler")));
+void epic_isr_max86150(api_int_id_t id)
+        __attribute__((weak, alias("__epic_isr_default_handler")));
+void epic_isr_bhi160_accelerometer(api_int_id_t id)
+        __attribute__((weak, alias("__epic_isr_default_handler")));
+void epic_isr_bhi160_magnetometer(api_int_id_t id)
+        __attribute__((weak, alias("__epic_isr_default_handler")));
+void epic_isr_bhi160_orientation(api_int_id_t id)
+        __attribute__((weak, alias("__epic_isr_default_handler")));
+void epic_isr_bhi160_gyroscope(api_int_id_t id)
+        __attribute__((weak, alias("__epic_isr_default_handler")));
 void epic_isr_rtc_alarm(api_int_id_t id)
         __attribute__((weak, alias("__epic_isr_default_handler")));
+void epic_isr_max30001_ecg(api_int_id_t id)
+        __attribute__((weak, alias("__epic_isr_default_handler")));
 
 /* Default handler stub */
 __attribute__((weak)) void epic_isr_default_handler(api_int_id_t id)
@@ -1139,15 +1415,6 @@ void __epic_isr_default_handler(api_int_id_t id)
 void __dispatch_isr(api_int_id_t id)
 {
         switch (id) {
-        case EPIC_INT_BHI160_ACCELEROMETER:
-                epic_isr_bhi160_accelerometer(id);
-                break;
-        case EPIC_INT_BHI160_ORIENTATION:
-                epic_isr_bhi160_orientation(id);
-                break;
-        case EPIC_INT_BHI160_GYROSCOPE:
-                epic_isr_bhi160_gyroscope(id);
-                break;
         case EPIC_INT_RESET:
                 __epic_isr_reset(id);
                 break;
@@ -1157,9 +1424,27 @@ void __dispatch_isr(api_int_id_t id)
         case EPIC_INT_CTRL_C:
                 epic_isr_ctrl_c(id);
                 break;
+        case EPIC_INT_MAX86150:
+                epic_isr_max86150(id);
+                break;
+        case EPIC_INT_BHI160_ACCELEROMETER:
+                epic_isr_bhi160_accelerometer(id);
+                break;
+        case EPIC_INT_BHI160_MAGNETOMETER:
+                epic_isr_bhi160_magnetometer(id);
+                break;
+        case EPIC_INT_BHI160_ORIENTATION:
+                epic_isr_bhi160_orientation(id);
+                break;
+        case EPIC_INT_BHI160_GYROSCOPE:
+                epic_isr_bhi160_gyroscope(id);
+                break;
         case EPIC_INT_RTC_ALARM:
                 epic_isr_rtc_alarm(id);
                 break;
+        case EPIC_INT_MAX30001_ECG:
+                epic_isr_max30001_ecg(id);
+                break;
         case (-1):
                 /* Ignore a spurious interrupt */
                 break;

card10-sys/vendor/server.c

+#include "modules/log.h"
+#include "epicardium.h"
+
+void __api_dispatch_call(uint32_t id, void*epc__apistub_buffer)
+{
+        switch (id) {
+        case API_INTERRUPT_ENABLE:
+                *((int*)epc__apistub_buffer) = epic_interrupt_enable(
+                        *(api_int_id_t*)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_INTERRUPT_DISABLE:
+                *((int*)epc__apistub_buffer) = epic_interrupt_disable(
+                        *(api_int_id_t*)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_SYSTEM_EXIT:
+                __epic_exit(
+                        *(int*)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_SYSTEM_EXEC:
+                *((int*)epc__apistub_buffer) = __epic_exec(
+                        *(char **)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_SYSTEM_RESET:
+                epic_system_reset(
+                );
+                break;
+        case API_BATTERY_VOLTAGE:
+                *((int*)epc__apistub_buffer) = epic_read_battery_voltage(
+                        *(float **)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_BATTERY_CURRENT:
+                *((int*)epc__apistub_buffer) = epic_read_battery_current(
+                        *(float **)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_CHARGEIN_VOLTAGE:
+                *((int*)epc__apistub_buffer) = epic_read_chargein_voltage(
+                        *(float **)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_CHARGEIN_CURRENT:
+                *((int*)epc__apistub_buffer) = epic_read_chargein_current(
+                        *(float **)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_SYSTEM_VOLTAGE:
+                *((int*)epc__apistub_buffer) = epic_read_system_voltage(
+                        *(float **)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_THERMISTOR_VOLTAGE:
+                *((int*)epc__apistub_buffer) = epic_read_thermistor_voltage(
+                        *(float **)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_UART_WRITE_STR:
+                epic_uart_write_str(
+                        *(const char **)(epc__apistub_buffer + 0),
+                        *(size_t*)(epc__apistub_buffer + sizeof(const char *))
+                );
+                break;
+        case API_UART_READ_CHAR:
+                *((int*)epc__apistub_buffer) = epic_uart_read_char(
+                );
+                break;
+        case API_UART_READ_STR:
+                *((int*)epc__apistub_buffer) = epic_uart_read_str(
+                        *(char **)(epc__apistub_buffer + 0),
+                        *(size_t*)(epc__apistub_buffer + sizeof(char *))
+                );
+                break;
+        case API_BUTTONS_READ:
+                *((uint8_t*)epc__apistub_buffer) = epic_buttons_read(
+                        *(uint8_t*)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_GPIO_SET_PIN_MODE:
+                *((int*)epc__apistub_buffer) = epic_gpio_set_pin_mode(
+                        *(uint8_t*)(epc__apistub_buffer + 0),
+                        *(uint8_t*)(epc__apistub_buffer + sizeof(uint8_t))
+                );
+                break;
+        case API_GPIO_GET_PIN_MODE:
+                *((int*)epc__apistub_buffer) = epic_gpio_get_pin_mode(
+                        *(uint8_t*)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_GPIO_WRITE_PIN:
+                *((int*)epc__apistub_buffer) = epic_gpio_write_pin(
+                        *(uint8_t*)(epc__apistub_buffer + 0),
+                        *(_Bool*)(epc__apistub_buffer + sizeof(uint8_t))
+                );
+                break;
+        case API_GPIO_READ_PIN:
+                *((int*)epc__apistub_buffer) = epic_gpio_read_pin(
+                        *(uint8_t*)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_LEDS_SET:
+                epic_leds_set(
+                        *(int*)(epc__apistub_buffer + 0),
+                        *(uint8_t*)(epc__apistub_buffer + sizeof(int)),
+                        *(uint8_t*)(epc__apistub_buffer + sizeof(int) + sizeof(uint8_t)),
+                        *(uint8_t*)(epc__apistub_buffer + sizeof(int) + sizeof(uint8_t) + sizeof(uint8_t))
+                );
+                break;
+        case API_LEDS_GET:
+                *((int*)epc__apistub_buffer) = epic_leds_get_rgb(
+                        *(int*)(epc__apistub_buffer + 0),
+                        *(uint8_t **)(epc__apistub_buffer + sizeof(int))
+                );
+                break;
+        case API_LEDS_SET_HSV:
+                epic_leds_set_hsv(
+                        *(int*)(epc__apistub_buffer + 0),
+                        *(float*)(epc__apistub_buffer + sizeof(int)),
+                        *(float*)(epc__apistub_buffer + sizeof(int) + sizeof(float)),
+                        *(float*)(epc__apistub_buffer + sizeof(int) + sizeof(float) + sizeof(float))
+                );
+                break;
+        case API_LEDS_SET_ALL:
+                epic_leds_set_all(
+                        *(uint8_t **)(epc__apistub_buffer + 0),
+                        *(uint8_t*)(epc__apistub_buffer + sizeof(uint8_t *))
+                );
+                break;
+        case API_LEDS_SET_ALL_HSV:
+                epic_leds_set_all_hsv(
+                        *(float **)(epc__apistub_buffer + 0),
+                        *(uint8_t*)(epc__apistub_buffer + sizeof(float *))
+                );
+                break;
+        case API_LEDS_PREP:
+                epic_leds_prep(
+                        *(int*)(epc__apistub_buffer + 0),
+                        *(uint8_t*)(epc__apistub_buffer + sizeof(int)),
+                        *(uint8_t*)(epc__apistub_buffer + sizeof(int) + sizeof(uint8_t)),
+                        *(uint8_t*)(epc__apistub_buffer + sizeof(int) + sizeof(uint8_t) + sizeof(uint8_t))
+                );
+                break;
+        case API_LEDS_PREP_HSV:
+                epic_leds_prep_hsv(
+                        *(int*)(epc__apistub_buffer + 0),
+                        *(float*)(epc__apistub_buffer + sizeof(int)),
+                        *(float*)(epc__apistub_buffer + sizeof(int) + sizeof(float)),
+                        *(float*)(epc__apistub_buffer + sizeof(int) + sizeof(float) + sizeof(float))
+                );
+                break;
+        case API_LEDS_DIM_BOTTOM:
+                epic_leds_dim_bottom(
+                        *(uint8_t*)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_LEDS_DIM_TOP:
+                epic_leds_dim_top(
+                        *(uint8_t*)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_LEDS_SET_POWERSAVE:
+                epic_leds_set_powersave(
+                        *(_Bool*)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_LEDS_UPDATE:
+                epic_leds_update(
+                );
+                break;
+        case API_LEDS_SET_ROCKET:
+                epic_leds_set_rocket(
+                        *(int*)(epc__apistub_buffer + 0),
+                        *(uint8_t*)(epc__apistub_buffer + sizeof(int))
+                );
+                break;
+        case API_LEDS_GET_ROCKET:
+                *((int*)epc__apistub_buffer) = epic_leds_get_rocket(
+                        *(int*)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_LEDS_SET_FLASHLIGHT:
+                epic_set_flashlight(
+                        *(_Bool*)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_LEDS_SET_GAMMA_TABLE:
+                epic_leds_set_gamma_table(
+                        *(uint8_t*)(epc__apistub_buffer + 0),
+                        *(uint8_t **)(epc__apistub_buffer + sizeof(uint8_t))
+                );
+                break;
+        case API_LEDS_CLEAR_ALL:
+                epic_leds_clear_all(
+                        *(uint8_t*)(epc__apistub_buffer + 0),
+                        *(uint8_t*)(epc__apistub_buffer + sizeof(uint8_t)),
+                        *(uint8_t*)(epc__apistub_buffer + sizeof(uint8_t) + sizeof(uint8_t))
+                );
+                break;
+        case API_BME680_INIT:
+                *((int*)epc__apistub_buffer) = epic_bme680_init(
+                );
+                break;
+        case API_BME680_DEINIT:
+                *((int*)epc__apistub_buffer) = epic_bme680_deinit(
+                );
+                break;
+        case API_BME680_GET_DATA:
+                *((int*)epc__apistub_buffer) = epic_bme680_read_sensors(
+                        *(struct bme680_sensor_data **)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_MAX86150_ENABLE:
+                *((int*)epc__apistub_buffer) = epic_max86150_enable_sensor(
+                        *(struct max86150_sensor_config **)(epc__apistub_buffer + 0),
+                        *(size_t*)(epc__apistub_buffer + sizeof(struct max86150_sensor_config *))
+                );
+                break;
+        case API_MAX86150_DISABLE:
+                *((int*)epc__apistub_buffer) = epic_max86150_disable_sensor(
+                );
+                break;
+        case API_PERSONAL_STATE_SET:
+                *((int*)epc__apistub_buffer) = epic_personal_state_set(
+                        *(uint8_t*)(epc__apistub_buffer + 0),
+                        *(_Bool*)(epc__apistub_buffer + sizeof(uint8_t))
+                );
+                break;
+        case API_PERSONAL_STATE_GET:
+                *((int*)epc__apistub_buffer) = epic_personal_state_get(
+                );
+                break;
+        case API_PERSONAL_STATE_IS_PERSISTENT:
+                *((int*)epc__apistub_buffer) = epic_personal_state_is_persistent(
+                );
+                break;
+        case API_STREAM_READ:
+                *((int*)epc__apistub_buffer) = epic_stream_read(
+                        *(int*)(epc__apistub_buffer + 0),
+                        *(void **)(epc__apistub_buffer + sizeof(int)),
+                        *(size_t*)(epc__apistub_buffer + sizeof(int) + sizeof(void *))
+                );
+                break;
+        case API_BHI160_ENABLE:
+                *((int*)epc__apistub_buffer) = epic_bhi160_enable_sensor(
+                        *(enum bhi160_sensor_type*)(epc__apistub_buffer + 0),
+                        *(struct bhi160_sensor_config **)(epc__apistub_buffer + sizeof(enum bhi160_sensor_type))
+                );
+                break;
+        case API_BHI160_DISABLE:
+                *((int*)epc__apistub_buffer) = epic_bhi160_disable_sensor(
+                        *(enum bhi160_sensor_type*)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_BHI160_DISABLE_ALL:
+                epic_bhi160_disable_all_sensors(
+                );
+                break;
+        case API_VIBRA_SET:
+                epic_vibra_set(
+                        *(int*)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_VIBRA_VIBRATE:
+                epic_vibra_vibrate(
+                        *(int*)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_DISP_OPEN:
+                *((int*)epc__apistub_buffer) = epic_disp_open(
+                );
+                break;
+        case API_DISP_CLOSE:
+                *((int*)epc__apistub_buffer) = epic_disp_close(
+                );
+                break;
+        case API_DISP_UPDATE:
+                *((int*)epc__apistub_buffer) = epic_disp_update(
+                );
+                break;
+        case API_DISP_PRINT:
+                *((int*)epc__apistub_buffer) = epic_disp_print(
+                        *(int16_t*)(epc__apistub_buffer + 0),
+                        *(int16_t*)(epc__apistub_buffer + sizeof(int16_t)),
+                        *(const char **)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t)),
+                        *(uint16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(const char *)),
+                        *(uint16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(const char *) + sizeof(uint16_t))
+                );
+                break;
+        case API_DISP_PRINT_ADV:
+                *((int*)epc__apistub_buffer) = epic_disp_print_adv(
+                        *(uint8_t*)(epc__apistub_buffer + 0),
+                        *(int16_t*)(epc__apistub_buffer + sizeof(uint8_t)),
+                        *(int16_t*)(epc__apistub_buffer + sizeof(uint8_t) + sizeof(int16_t)),
+                        *(const char **)(epc__apistub_buffer + sizeof(uint8_t) + sizeof(int16_t) + sizeof(int16_t)),
+                        *(uint16_t*)(epc__apistub_buffer + sizeof(uint8_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(const char *)),
+                        *(uint16_t*)(epc__apistub_buffer + sizeof(uint8_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(const char *) + sizeof(uint16_t))
+                );
+                break;
+        case API_DISP_CLEAR:
+                *((int*)epc__apistub_buffer) = epic_disp_clear(
+                        *(uint16_t*)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_DISP_PIXEL:
+                *((int*)epc__apistub_buffer) = epic_disp_pixel(
+                        *(int16_t*)(epc__apistub_buffer + 0),
+                        *(int16_t*)(epc__apistub_buffer + sizeof(int16_t)),
+                        *(uint16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t))
+                );
+                break;
+        case API_DISP_LINE:
+                *((int*)epc__apistub_buffer) = epic_disp_line(
+                        *(int16_t*)(epc__apistub_buffer + 0),
+                        *(int16_t*)(epc__apistub_buffer + sizeof(int16_t)),
+                        *(int16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t)),
+                        *(int16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t)),
+                        *(uint16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t)),
+                        *(enum disp_linestyle*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(uint16_t)),
+                        *(uint16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(uint16_t) + sizeof(enum disp_linestyle))
+                );
+                break;
+        case API_DISP_RECT:
+                *((int*)epc__apistub_buffer) = epic_disp_rect(
+                        *(int16_t*)(epc__apistub_buffer + 0),
+                        *(int16_t*)(epc__apistub_buffer + sizeof(int16_t)),
+                        *(int16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t)),
+                        *(int16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t)),
+                        *(uint16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t)),
+                        *(enum disp_fillstyle*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(uint16_t)),
+                        *(uint16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(int16_t) + sizeof(uint16_t) + sizeof(enum disp_fillstyle))
+                );
+                break;
+        case API_DISP_CIRC:
+                *((int*)epc__apistub_buffer) = epic_disp_circ(
+                        *(int16_t*)(epc__apistub_buffer + 0),
+                        *(int16_t*)(epc__apistub_buffer + sizeof(int16_t)),
+                        *(uint16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t)),
+                        *(uint16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(uint16_t)),
+                        *(enum disp_fillstyle*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(uint16_t) + sizeof(uint16_t)),
+                        *(uint16_t*)(epc__apistub_buffer + sizeof(int16_t) + sizeof(int16_t) + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(enum disp_fillstyle))
+                );
+                break;
+        case API_DISP_FRAMEBUFFER:
+                *((int*)epc__apistub_buffer) = epic_disp_framebuffer(
+                        *(union disp_framebuffer **)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_DISP_BACKLIGHT:
+                *((int*)epc__apistub_buffer) = epic_disp_backlight(
+                        *(uint16_t*)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_LIGHT_SENSOR_RUN:
+                *((int*)epc__apistub_buffer) = epic_light_sensor_run(
+                );
+                break;
+        case API_LIGHT_SENSOR_GET:
+                *((int*)epc__apistub_buffer) = epic_light_sensor_get(
+                        *(uint16_t**)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_LIGHT_SENSOR_STOP:
+                *((int*)epc__apistub_buffer) = epic_light_sensor_stop(
+                );
+                break;
+        case API_LIGHT_SENSOR_READ:
+                *((uint16_t*)epc__apistub_buffer) = epic_light_sensor_read(
+                );
+                break;
+        case API_FILE_OPEN:
+                *((int*)epc__apistub_buffer) = epic_file_open(
+                        *(const char**)(epc__apistub_buffer + 0),
+                        *(const char**)(epc__apistub_buffer + sizeof(const char*))
+                );
+                break;
+        case API_FILE_CLOSE:
+                *((int*)epc__apistub_buffer) = epic_file_close(
+                        *(int*)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_FILE_READ:
+                *((int*)epc__apistub_buffer) = epic_file_read(
+                        *(int*)(epc__apistub_buffer + 0),
+                        *(void**)(epc__apistub_buffer + sizeof(int)),
+                        *(size_t*)(epc__apistub_buffer + sizeof(int) + sizeof(void*))
+                );
+                break;
+        case API_FILE_WRITE:
+                *((int*)epc__apistub_buffer) = epic_file_write(
+                        *(int*)(epc__apistub_buffer + 0),
+                        *(const void**)(epc__apistub_buffer + sizeof(int)),
+                        *(size_t*)(epc__apistub_buffer + sizeof(int) + sizeof(const void*))
+                );
+                break;
+        case API_FILE_FLUSH:
+                *((int*)epc__apistub_buffer) = epic_file_flush(
+                        *(int*)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_FILE_SEEK:
+                *((int*)epc__apistub_buffer) = epic_file_seek(
+                        *(int*)(epc__apistub_buffer + 0),
+                        *(long*)(epc__apistub_buffer + sizeof(int)),
+                        *(int*)(epc__apistub_buffer + sizeof(int) + sizeof(long))
+                );
+                break;
+        case API_FILE_TELL:
+                *((int*)epc__apistub_buffer) = epic_file_tell(
+                        *(int*)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_FILE_STAT:
+                *((int*)epc__apistub_buffer) = epic_file_stat(
+                        *(const char**)(epc__apistub_buffer + 0),
+                        *(struct epic_stat**)(epc__apistub_buffer + sizeof(const char*))
+                );
+                break;
+        case API_FILE_OPENDIR:
+                *((int*)epc__apistub_buffer) = epic_file_opendir(
+                        *(const char**)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_FILE_READDIR:
+                *((int*)epc__apistub_buffer) = epic_file_readdir(
+                        *(int*)(epc__apistub_buffer + 0),
+                        *(struct epic_stat**)(epc__apistub_buffer + sizeof(int))
+                );
+                break;
+        case API_FILE_UNLINK:
+                *((int*)epc__apistub_buffer) = epic_file_unlink(
+                        *(const char**)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_FILE_RENAME:
+                *((int*)epc__apistub_buffer) = epic_file_rename(
+                        *(const char **)(epc__apistub_buffer + 0),
+                        *(const char**)(epc__apistub_buffer + sizeof(const char *))
+                );
+                break;
+        case API_FILE_MKDIR:
+                *((int*)epc__apistub_buffer) = epic_file_mkdir(
+                        *(const char **)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_RTC_GET_MONOTONIC_SECONDS:
+                *((uint32_t*)epc__apistub_buffer) = epic_rtc_get_monotonic_seconds(
+                );
+                break;
+        case API_RTC_GET_MONOTONIC_MILLISECONDS:
+                *((uint64_t*)epc__apistub_buffer) = epic_rtc_get_monotonic_milliseconds(
+                );
+                break;
+        case API_RTC_GET_SECONDS:
+                *((uint32_t*)epc__apistub_buffer) = epic_rtc_get_seconds(
+                );
+                break;
+        case API_RTC_GET_MILLISECONDS:
+                *((uint64_t*)epc__apistub_buffer) = epic_rtc_get_milliseconds(
+                );
+                break;
+        case API_RTC_SET_MILLISECONDS:
+                epic_rtc_set_milliseconds(
+                        *(uint64_t*)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_RTC_SCHEDULE_ALARM:
+                *((int*)epc__apistub_buffer) = epic_rtc_schedule_alarm(
+                        *(uint32_t*)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_TRNG_READ:
+                *((int*)epc__apistub_buffer) = epic_trng_read(
+                        *(uint8_t **)(epc__apistub_buffer + 0),
+                        *(size_t*)(epc__apistub_buffer + sizeof(uint8_t *))
+                );
+                break;
+        case API_MAX30001_ENABLE:
+                *((int*)epc__apistub_buffer) = epic_max30001_enable_sensor(
+                        *(struct max30001_sensor_config **)(epc__apistub_buffer + 0)
+                );
+                break;
+        case API_MAX30001_DISABLE:
+                *((int*)epc__apistub_buffer) = epic_max30001_disable_sensor(
+                );
+                break;
+        case API_USB_SHUTDOWN:
+                *((int*)epc__apistub_buffer) = epic_usb_shutdown(
+                );
+                break;
+        case API_USB_STORAGE:
+                *((int*)epc__apistub_buffer) = epic_usb_storage(
+                );
+                break;
+        case API_USB_CDCACM:
+                *((int*)epc__apistub_buffer) = epic_usb_cdcacm(
+                );
+                break;
+        case API_WS2812_WRITE:
+                epic_ws2812_write(
+                        *(uint8_t*)(epc__apistub_buffer + 0),
+                        *(uint8_t **)(epc__apistub_buffer + sizeof(uint8_t)),
+                        *(uint32_t*)(epc__apistub_buffer + sizeof(uint8_t) + sizeof(uint8_t *))
+                );
+                break;
+        case API_CONFIG_GET_INTEGER:
+                *((int*)epc__apistub_buffer) = epic_config_get_integer(
+                        *(const char **)(epc__apistub_buffer + 0),
+                        *(int **)(epc__apistub_buffer + sizeof(const char *))
+                );
+                break;
+        case API_CONFIG_GET_BOOLEAN:
+                *((int*)epc__apistub_buffer) = epic_config_get_boolean(
+                        *(const char **)(epc__apistub_buffer + 0),
+                        *(_Bool **)(epc__apistub_buffer + sizeof(const char *))
+                );
+                break;
+        case API_CONFIG_GET_STRING:
+                *((int*)epc__apistub_buffer) = epic_config_get_string(
+                        *(const char **)(epc__apistub_buffer + 0),
+                        *(char **)(epc__apistub_buffer + sizeof(const char *)),
+                        *(size_t*)(epc__apistub_buffer + sizeof(const char *) + sizeof(char *))
+                );
+                break;
+        default:
+                /* TODO: Better error handling */
+                LOG_ERR("api-dispatcher", "API function 0x%lx is unknown!!", id);
+                break;
+        }
+}