epicardium/drivers/display/lcd.c

+#include "os/core.h"
+
+#include "MAX77650-Arduino-Library.h"
+#include "gpio.h"
+#include "mxc_delay.h"
+#include "portexpander.h"
+#include "spi.h"
+
+#include <machine/endian.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+/* HAL Interfaces {{{ */
+static const gpio_cfg_t GPIO_PIN_DC = {
+	PORT_1, PIN_6, GPIO_FUNC_OUT, GPIO_PAD_NONE
+};
+
+static void lcd_hw_init(void)
+{
+	GPIO_Config(&GPIO_PIN_DC);
+
+	/* for the reset pin */
+	if (!portexpander_detected()) {
+		/* Open-drain */
+		MAX77650_setDRV(false);
+		/* Output */
+		MAX77650_setDIR(false);
+	}
+}
+
+static void lcd_set_dc(bool state)
+{
+	if (state) {
+		GPIO_OutSet(&GPIO_PIN_DC);
+	} else {
+		GPIO_OutClr(&GPIO_PIN_DC);
+	}
+}
+
+static void lcd_set_rst(bool state)
+{
+	if (!portexpander_detected()) {
+		MAX77650_setDO(state ? true : false);
+	} else {
+		portexpander_out_put(PIN_4, state ? 0xFF : 0);
+	}
+}
+
+/** Bit Rate. Display has 15 MHz limit */
+#define SPI_SPEED (15 * 1000 * 1000)
+
+static void lcd_spi_write(const uint8_t *data, size_t count)
+{
+	const sys_cfg_spi_t spi_master_cfg = {
+		.map    = MAP_A,
+		.ss0    = Enable,
+		.ss1    = Disable,
+		.ss2    = Disable,
+		.num_io = 2,
+	};
+	spi_req_t request = {
+		.ssel     = 0,
+		.deass    = 1,
+		.ssel_pol = SPI17Y_POL_LOW,
+		.tx_data  = data,
+		.rx_data  = NULL,
+		.width    = SPI17Y_WIDTH_1,
+		.len      = count,
+		.bits     = 8,
+		.rx_num   = 0,
+		.tx_num   = 0,
+		.callback = NULL,
+	};
+	if (SPI_Init(SPI2, 0, SPI_SPEED, spi_master_cfg) != 0) {
+		panic("Error configuring display SPI");
+	}
+	SPI_MasterTrans(SPI2, &request);
+}
+
+static void lcd_delay(size_t millis)
+{
+	// TODO: Is this what we want?
+	mxc_delay(millis * 1000);
+}
+/* HAL Interfaces }}} */
+
+enum lcd_commands {
+	/** Sleep In */
+	LCD_SLPIN = 0x10,
+	/** Sleep Out */
+	LCD_SLPOUT = 0x11,
+	/** Display Inversion On */
+	LCD_INVON = 0x21,
+	/** Display On */
+	LCD_DISPON = 0x29,
+	/** Column Address Set */
+	LCD_CASET = 0x2A,
+	/** Row Address Set */
+	LCD_RASET = 0x2B,
+	/** Memory Write */
+	LCD_RAMWR = 0x2C,
+	/** Memory Data Access Control */
+	LCD_MADCTL = 0x36,
+	/** Interface Pixel Format */
+	LCD_COLMOD = 0x3A,
+	/** Frame Rate Control (In normal mode/ Full colors) */
+	LCD_FRMCTR1 = 0xB1,
+	/** Frame Rate Control (In Idle mode/ 8-colors) */
+	LCD_FRMCTR2 = 0xB2,
+	/** Frame Rate Control (In Partial mode/ full colors) */
+	LCD_FRMCTR3 = 0xB3,
+	/** Display Inversion Control */
+	LCD_INVCTR = 0xB4,
+	/** Power Control 1 */
+	LCD_PWCTR1 = 0xC0,
+	/** Power Control 2 */
+	LCD_PWCTR2 = 0xC1,
+	/** Power Control 3 (in Normal mode/ Full colors) */
+	LCD_PWCTR3 = 0xC2,
+	/** Power Control 4 (in Idle mode/ 8-colors) */
+	LCD_PWCTR4 = 0xC3,
+	/** Power Control 5 (in Partial mode/ full-colors) */
+	LCD_PWCTR5 = 0xC4,
+	/** VCOM Control 1 */
+	LCD_VMCTR1 = 0xC5,
+	/** Gamma (+ polarity) Correction Characteristics Setting */
+	LCD_GMCTRP1 = 0xE0,
+	/** Gamma (- polarity) Correction Characteristics Setting */
+	LCD_GMCTRN1 = 0xE1,
+};
+
+enum madctl_bits {
+	MADCTL_MY  = 0x80,
+	MADCTL_MX  = 0x40,
+	MADCTL_MV  = 0x20,
+	MADCTL_ML  = 0x10,
+	MADCTL_RGB = 0x08,
+	MADCTL_MH  = 0x04,
+};
+
+static void
+lcd_send_command(enum lcd_commands cmd, const uint8_t *args, size_t count)
+{
+	lcd_set_dc(false);
+	lcd_spi_write((uint8_t *)&cmd, 1);
+	if (args != NULL && count != 0) {
+		lcd_set_dc(true);
+		lcd_spi_write(args, count);
+	}
+}
+
+static void lcd_hard_reset(void)
+{
+	lcd_delay(20);
+	lcd_set_rst(false);
+	lcd_delay(20);
+	lcd_set_rst(true);
+	lcd_delay(20);
+}
+
+void lcd_set_sleep(bool sleep)
+{
+	static int current_sleep = -1;
+
+	if (sleep == current_sleep) {
+		return;
+	}
+	current_sleep = sleep;
+
+	if (sleep) {
+		lcd_send_command(LCD_SLPIN, NULL, 0);
+	} else {
+		lcd_send_command(LCD_SLPOUT, NULL, 0);
+	}
+}
+
+/**
+ * Perform a minimal initialization under the assumption that the bootloader has
+ * already turned on the display.  This is faster and prevents visible
+ * reinitialization artifacts.
+ */
+void lcd_reconfigure(void)
+{
+	/* Invert Display (twice for unknown reasons ...). */
+	lcd_send_command(LCD_INVON, NULL, 0);
+	lcd_send_command(LCD_INVON, NULL, 0);
+
+	/* Set framerate control values for all modes to the same values. */
+	const uint8_t frmctr[] = { 0x05, 0x3A, 0x3A, 0x05, 0x3A, 0x3A };
+	lcd_send_command(LCD_FRMCTR1, frmctr, 3);
+	lcd_send_command(LCD_FRMCTR2, frmctr, 3);
+	lcd_send_command(LCD_FRMCTR3, frmctr, 6);
+
+	/* Set display inversion control (unsure what this does?). */
+	const uint8_t invctr[] = { 0x03 };
+	lcd_send_command(LCD_INVCTR, invctr, sizeof(invctr));
+
+	/* Configure GVDD voltage to 4.7V. */
+	const uint8_t pwctr1[] = { 0x62, 0x02, 0x04 };
+	lcd_send_command(LCD_PWCTR1, pwctr1, sizeof(pwctr1));
+
+	/* Configure only ignored bits? */
+	const uint8_t pwctr2[] = { 0xC0 };
+	lcd_send_command(LCD_PWCTR2, pwctr2, sizeof(pwctr2));
+
+	/*
+	 * Configure "large" amount of current in operational amplifier and
+	 * booster step-ups for all modes.
+	 */
+	const uint8_t pwctr3[] = { 0x0D, 0x00 }, pwctr4[] = { 0x8D, 0x6A },
+		      pwctr5[] = { 0x8D, 0xEE };
+	lcd_send_command(LCD_PWCTR3, pwctr3, sizeof(pwctr3));
+	lcd_send_command(LCD_PWCTR4, pwctr4, sizeof(pwctr4));
+	lcd_send_command(LCD_PWCTR5, pwctr5, sizeof(pwctr5));
+
+	/* Configure VCOMH voltage to 2.850V. */
+	const uint8_t vmctr1[] = { 0x0E };
+	lcd_send_command(LCD_VMCTR1, vmctr1, sizeof(vmctr1));
+
+	/* Write positive and negative gamma correction values. */
+	const uint8_t gmctrp1[] = {
+		0x10, 0x0E, 0x02, 0x03, 0x0E, 0x07, 0x02, 0x07,
+		0x0A, 0x12, 0x27, 0x37, 0x00, 0x0D, 0x0E, 0x10,
+	};
+	const uint8_t gmctrn1[] = {
+		0x10, 0x0E, 0x03, 0x03, 0x0F, 0x06, 0x02, 0x08,
+		0x0A, 0x13, 0x26, 0x36, 0x00, 0x0D, 0x0E, 0x10,
+	};
+	lcd_send_command(LCD_GMCTRP1, gmctrp1, sizeof(gmctrp1));
+	lcd_send_command(LCD_GMCTRN1, gmctrn1, sizeof(gmctrn1));
+
+	/* Configure 16-bit pixel format. */
+	const uint8_t colmod[] = { 0x05 };
+	lcd_send_command(LCD_COLMOD, colmod, sizeof(colmod));
+
+	/*
+	 * Configure "MADCTL", which defines the pixel and color access order.
+	 */
+	const uint8_t madctl[] = { MADCTL_MX | MADCTL_MV | MADCTL_RGB };
+	/*
+	 * Waveshare Driver:
+	 * const uint8_t madctl[] = { MADCTL_MY | MADCTL_MV | MADCTL_RGB };
+	 */
+	lcd_send_command(LCD_MADCTL, madctl, sizeof(madctl));
+
+	/* Turn the display on. */
+	lcd_send_command(LCD_DISPON, NULL, 0);
+}
+
+/**
+ * Perform a full initialization of the display.  This will ensure the display
+ * is in a deterministic state.
+ */
+void lcd_initialize(void)
+{
+	lcd_hw_init();
+
+	lcd_hard_reset();
+
+	lcd_send_command(LCD_SLPOUT, NULL, 0);
+	lcd_delay(120);
+
+	lcd_reconfigure();
+}
+
+/**
+ * Write a partial display update.
+ *
+ * The rectangle from column ``xstart`` to ``xend`` (inclusive) and row
+ * ``ystart`` to ``yend`` (inclusive) will be updated with the contents of
+ * ``fb``.
+ *
+ * ``fb`` **must** have a size of
+ * ``(xend - xstart + 1) * (yend - ystart + 1) * 2`` bytes.
+ */
+void lcd_write_fb_partial(
+	uint16_t xstart,
+	uint16_t ystart,
+	uint16_t xend,
+	uint16_t yend,
+	const uint8_t *fb
+) {
+	uint16_t param_buffer[2];
+
+	/* Column start and end are offset by 1. */
+	param_buffer[0] = __htons(xstart + 1);
+	param_buffer[1] = __htons(xend + 1);
+	lcd_send_command(
+		LCD_CASET, (uint8_t *)param_buffer, sizeof(param_buffer)
+	);
+
+	/* Row start and end are offset by a magic 26. */
+	param_buffer[0] = __htons(ystart + 26);
+	param_buffer[1] = __htons(yend + 26);
+	lcd_send_command(
+		LCD_RASET, (uint8_t *)param_buffer, sizeof(param_buffer)
+	);
+
+	/* Now write out the actual framebuffer contents. */
+	size_t fb_size = (xend - xstart + 1) * (yend - ystart + 1) * 2;
+	lcd_send_command(LCD_RAMWR, fb, fb_size);
+}
+
+/**
+ * Write out a full framebuffer update.
+ *
+ * ``fb`` **must** be 160 * 80 * 2 = **25600** bytes in size.  The pixels are
+ * ordered in rows starting at the top left of the screen.  Each pixel must have
+ * its bytes laid out as big endian (while the CPU is little endian!).
+ */
+void lcd_write_fb(const uint8_t *fb)
+{
+	lcd_write_fb_partial(0, 0, 159, 79, fb);
+}
+
+/**
+ * Flip the screen orientation upside down.
+ *
+ * Historically we had software perform a flip of the framebuffer before
+ * sending it out.  This function provides a way to make the hardware accept
+ * such a flipped framebuffer.  This exists mostly to support the
+ * :c:func:`epic_disp_framebuffer()` API call for legacy l0dables.
+ */
+void lcd_set_screenflip(bool flipped)
+{
+	const uint8_t madctl_upright[] = { MADCTL_MX | MADCTL_MV | MADCTL_RGB };
+	const uint8_t madctl_flipped[] = { MADCTL_MY | MADCTL_MV | MADCTL_RGB };
+	if (flipped) {
+		lcd_send_command(LCD_MADCTL, madctl_flipped, 1);
+	} else {
+		lcd_send_command(LCD_MADCTL, madctl_upright, 1);
+	}
+}

epicardium/drivers/display/lcd.h

+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+
+void lcd_set_sleep(bool sleep);
+void lcd_reconfigure(void);
+void lcd_initialize(void);
+void lcd_write_fb_partial(
+	uint16_t xstart,
+	uint16_t ystart,
+	uint16_t xend,
+	uint16_t yend,
+	const uint8_t *fb
+);
+void lcd_write_fb(const uint8_t *fb);
+void lcd_set_screenflip(bool flipped);

epicardium/drivers/drivers.h

+#ifndef DRIVERS_H
+#define DRIVERS_H
+
+#include "FreeRTOS.h"
+#include "gpio.h"
+#include "os/mutex.h"
+#include "epicardium.h"
+
+#include <stdint.h>
+#include <stdbool.h>
+
+/* ---------- Serial ------------------------------------------------------- */
+#define SERIAL_READ_BUFFER_SIZE 128
+#define SERIAL_WRITE_STREAM_BUFFER_SIZE 512
+void serial_init();
+void vSerialTask(void *pvParameters);
+void serial_enqueue_char(char chr);
+void serial_flush(void);
+extern TaskHandle_t serial_task_id;
+/* Turn off the print queue and do prints synchroneous from now on. */
+void serial_return_to_synchronous();
+
+// For the eSetBit xTaskNotify task semaphore trigger
+enum serial_notify{
+	SERIAL_WRITE_NOTIFY = 0x01,
+	SERIAL_READ_NOTIFY  = 0x02,
+};
+
+/* ---------- PMIC --------------------------------------------------------- */
+void vPmicTask(void *pvParameters);
+
+/* ---------- Watchdog ----------------------------------------------------- */
+void watchdog_init();
+void watchdog_clearer_init();
+
+/* Critical battery voltage */
+#define BATTERY_CRITICAL   3.40f
+
+enum pmic_amux_signal {
+	PMIC_AMUX_DISABLED    = 0x0,
+	PMIC_AMUX_CHGIN_U     = 0x1,
+	PMIC_AMUX_CHGIN_I     = 0x2,
+	PMIC_AMUX_BATT_U      = 0x3,
+	PMIC_AMUX_BATT_CHG_I  = 0x4,
+	PMIC_AMUX_BATT_DIS_I  = 0x5,
+	PMIC_AMUX_BATT_NULL_I = 0x6,
+	PMIC_AMUX_THM_U       = 0x7,
+	PMIC_AMUX_TBIAS_U     = 0x8,
+	PMIC_AMUX_AGND_U      = 0x9,
+	PMIC_AMUX_SYS_U       = 0xA,
+	_PMIC_AMUX_MAX,
+};
+
+/*
+ * Read a value from the PMIC's AMUX.  The result is already converted into its
+ * proper unit.  See the MAX77650 datasheet for details.
+ */
+int pmic_read_amux(enum pmic_amux_signal sig, float *result);
+
+
+/* ---------- Display ------------------------------------------------------ */
+/* Do display and graphics initialization/configuration. */
+void disp_init(void);
+/* Reinitialize the graphics context. */
+void disp_ctx_reinit(void);
+/* Forces an unlock of the display. Only to be used in Epicardium */
+void disp_forcelock();
+void disp_update_backlight_clock(void);
+
+/* ---------- BHI160 ------------------------------------------------------- */
+#define BHI160_FIFO_SIZE             128
+#define BHI160_MUTEX_WAIT_MS          50
+void vBhi160Task(void *pvParameters);
+
+/* ---------- BME680 ------------------------------------------------------- */
+void bme680_periodic(int period);
+
+/* ---------- MAX86150 ----------------------------------------------------- */
+#define MAX86150_MUTEX_WAIT_MS		50
+void vMAX86150Task(void *pvParameters);
+void max86150_mutex_init(void);
+
+
+/* ---------- MAX30001 ----------------------------------------------------- */
+void vMAX30001Task(void *pvParameters);
+void max30001_mutex_init(void);
+
+/* ---------- GPIO --------------------------------------------------------- */
+extern gpio_cfg_t gpio_configs[];
+
+/* ---------- BSEC / BME680 ------------------------------------------------ */
+int bsec_activate(void);
+void vBSECTask(void *pvParameters);
+bool bsec_active(void);
+struct bme680_sensor_data;
+int bsec_read_bme680(struct bme680_sensor_data *data);
+
+/* ---------- Sleep -------------------------------------------------------- */
+void sleep_deepsleep(void);
+
+/* ---------- RNG ---------------------------------------------------------- */
+void rng_init(void);
+
+#endif /* DRIVERS_H */

epicardium/drivers/gpio.c

+#include "epicardium.h"
+#include "gpio.h"
+#include "max32665.h"
+#include "mxc_sys.h"
+#include "adc.h"
+#include "mxc_errors.h"
+#include "os/core.h"
+#include "modules/modules.h"
+
+/*
+ * Despite what the schematic (currently, 2019-08-18) says these are the correct
+ * pins for wristband GPIO 1-4 (not 0-3 as the schematic states)
+ */
+gpio_cfg_t gpio_configs[] = {
+	[EPIC_GPIO_WRISTBAND_1] = { PORT_0,
+				    PIN_21,
+				    GPIO_FUNC_OUT,
+				    GPIO_PAD_NONE },
+	[EPIC_GPIO_WRISTBAND_2] = { PORT_0,
+				    PIN_22,
+				    GPIO_FUNC_OUT,
+				    GPIO_PAD_NONE },
+	[EPIC_GPIO_WRISTBAND_3] = { PORT_0,
+				    PIN_29,
+				    GPIO_FUNC_OUT,
+				    GPIO_PAD_NONE },
+	[EPIC_GPIO_WRISTBAND_4] = { PORT_0,
+				    PIN_20,
+				    GPIO_FUNC_OUT,
+				    GPIO_PAD_NONE },
+};
+
+static int s_adc_channels[] = {
+	[EPIC_GPIO_WRISTBAND_1] = ADC_CH_5,
+	[EPIC_GPIO_WRISTBAND_2] = ADC_CH_6,
+	/* on P0.29, there is no ADC available
+	 * see GPIO matrix in MAX32665-MAX32668.pdf,
+	 * pages 32,33
+	 */
+	[EPIC_GPIO_WRISTBAND_3] = -1,
+	[EPIC_GPIO_WRISTBAND_4] = ADC_CH_4,
+};
+
+int epic_gpio_set_pin_mode(uint8_t pin, uint8_t mode)
+{
+	if (pin < EPIC_GPIO_WRISTBAND_1 || pin > EPIC_GPIO_WRISTBAND_4)
+		return -EINVAL;
+
+	gpio_cfg_t *cfg = &gpio_configs[pin];
+
+	if (mode & EPIC_GPIO_MODE_ADC) {
+		if (s_adc_channels[pin] == -1) {
+			LOG_WARN("gpio", "ADC not available on pin %d", pin);
+			return -EINVAL;
+		}
+		cfg->func = GPIO_FUNC_ALT1;
+		if (mode & EPIC_GPIO_MODE_OUT) {
+			return -EINVAL;
+		}
+	} else if (mode & EPIC_GPIO_MODE_IN) {
+		cfg->func = GPIO_FUNC_IN;
+		if (mode & EPIC_GPIO_MODE_OUT) {
+			return -EINVAL;
+		}
+	} else if (mode & EPIC_GPIO_MODE_OUT) {
+		cfg->func = GPIO_FUNC_OUT;
+		if (mode & EPIC_GPIO_MODE_IN) {
+			return -EINVAL;
+		}
+	} else {
+		return -EINVAL;
+	}
+
+	if (!(mode & EPIC_GPIO_MODE_ADC)) {
+		if (mode & EPIC_GPIO_PULL_UP) {
+			cfg->pad = GPIO_PAD_PULL_UP;
+		} else if (mode & EPIC_GPIO_PULL_DOWN) {
+			cfg->pad = GPIO_PAD_PULL_DOWN;
+		} else {
+			cfg->pad = GPIO_PAD_NONE;
+		}
+	} else {
+		cfg->pad = GPIO_PAD_NONE;
+	}
+
+	if (GPIO_Config(cfg) != E_NO_ERROR)
+		return -EINVAL;
+	return 0;
+}
+
+int epic_gpio_get_pin_mode(uint8_t pin)
+{
+	if (pin < EPIC_GPIO_WRISTBAND_1 || pin > EPIC_GPIO_WRISTBAND_4)
+		return -EINVAL;
+
+	gpio_cfg_t *cfg = &gpio_configs[pin];
+	int res         = 0;
+	if (cfg->func == GPIO_FUNC_IN)
+		res |= EPIC_GPIO_MODE_IN;
+	else if (cfg->func == GPIO_FUNC_OUT)
+		res |= EPIC_GPIO_MODE_OUT;
+	else if (cfg->func == GPIO_FUNC_ALT1)
+		res |= EPIC_GPIO_MODE_ADC;
+	if (cfg->pad == GPIO_PAD_PULL_UP)
+		res |= EPIC_GPIO_PULL_UP;
+	else if (cfg->pad == GPIO_PAD_PULL_DOWN)
+		res |= EPIC_GPIO_PULL_DOWN;
+
+	return res;
+}
+
+int epic_gpio_write_pin(uint8_t pin, bool on)
+{
+	if (pin < EPIC_GPIO_WRISTBAND_1 || pin > EPIC_GPIO_WRISTBAND_4)
+		return -EINVAL;
+
+	gpio_cfg_t *cfg = &gpio_configs[pin];
+	if (cfg->func == GPIO_FUNC_IN)
+		return -EINVAL;
+
+	if (on)
+		GPIO_OutSet(cfg);
+	else
+		GPIO_OutClr(cfg);
+
+	return 0;
+}
+
+int epic_gpio_read_pin(uint8_t pin)
+{
+	if (pin < EPIC_GPIO_WRISTBAND_1 || pin > EPIC_GPIO_WRISTBAND_4)
+		return -EINVAL;
+
+	gpio_cfg_t *cfg = &gpio_configs[pin];
+	if (cfg->func == GPIO_FUNC_OUT) {
+		return GPIO_OutGet(cfg) != 0;
+	} else if (cfg->func == GPIO_FUNC_IN) {
+		return GPIO_InGet(cfg) != 0;
+	} else if (cfg->func == GPIO_FUNC_ALT1) {
+		hwlock_acquire(HWLOCK_ADC);
+		ADC_StartConvert(s_adc_channels[pin], 0, 0);
+		uint16_t value;
+		int rc = ADC_GetData(&value);
+		hwlock_release(HWLOCK_ADC);
+		if (rc < 0) {
+			return -EIO;
+		}
+		return (int)value;
+	} else {
+		return -EINVAL;
+	}
+}

epicardium/drivers/leds.c

+#include "leds.h"
+#include "pmic.h"
+#include "FreeRTOS.h"
+#include "timers.h"
+#include "task.h"
+#include "epicardium.h"
+#include "modules/modules.h"
+
+#include <stdbool.h>
+
+/*
+ * TODO: create smth like vTaskDelay(pdMS_TO_TICKS(//put ms here)) for us,
+ *       remove blocking delay from /lib/leds.c to avoid process blocking
+ */
+
+#define NUM_LEDS 15 /* Take from lib/card10/leds.c */
+
+static void do_update(void)
+{
+	hwlock_acquire(HWLOCK_LED);
+	hwlock_acquire(HWLOCK_I2C);
+
+	leds_update_power();
+	leds_update();
+
+	hwlock_release(HWLOCK_I2C);
+	hwlock_release(HWLOCK_LED);
+}
+
+void epic_leds_set(int led, uint8_t r, uint8_t g, uint8_t b)
+{
+	if (led == PERSONAL_STATE_LED && personal_state_enabled())
+		return;
+
+	leds_prep(led, r, g, b);
+	do_update();
+}
+
+void epic_leds_set_hsv(int led, float h, float s, float v)
+{
+	if (led == PERSONAL_STATE_LED && personal_state_enabled())
+		return;
+
+	leds_prep_hsv(led, h, s, v);
+	do_update();
+}
+
+void epic_leds_prep(int led, uint8_t r, uint8_t g, uint8_t b)
+{
+	if (led == PERSONAL_STATE_LED && personal_state_enabled())
+		return;
+
+	leds_prep(led, r, g, b);
+}
+
+int epic_leds_get_rgb(int led, uint8_t *rgb)
+{
+	if (led == PERSONAL_STATE_LED && personal_state_enabled())
+		return -EPERM;
+	if (led < 0 || led >= NUM_LEDS)
+		return -EINVAL;
+
+	leds_get_rgb(led, rgb);
+	return 0;
+}
+
+void epic_leds_prep_hsv(int led, float h, float s, float v)
+{
+	if (led == PERSONAL_STATE_LED && personal_state_enabled())
+		return;
+
+	leds_prep_hsv(led, h, s, v);
+}
+
+void epic_leds_set_all(uint8_t *pattern_ptr, uint8_t len)
+{
+	uint8_t(*pattern)[3] = (uint8_t(*)[3])pattern_ptr;
+	for (int i = 0; i < len; i++) {
+		if (i == PERSONAL_STATE_LED && personal_state_enabled())
+			continue;
+
+		leds_prep(i, pattern[i][0], pattern[i][1], pattern[i][2]);
+	}
+	do_update();
+}
+
+void epic_leds_set_all_hsv(float *pattern_ptr, uint8_t len)
+{
+	float(*pattern)[3] = (float(*)[3])pattern_ptr;
+	for (int i = 0; i < len; i++) {
+		if (i == PERSONAL_STATE_LED && personal_state_enabled())
+			continue;
+
+		leds_prep_hsv(i, pattern[i][0], pattern[i][1], pattern[i][2]);
+	}
+	do_update();
+}
+
+void epic_leds_dim_top(uint8_t value)
+{
+	leds_set_dim_top(value);
+	if (personal_state_enabled() == 0) {
+		do_update();
+	}
+}
+
+void epic_leds_dim_bottom(uint8_t value)
+{
+	leds_set_dim_bottom(value);
+	if (personal_state_enabled() == 0) {
+		do_update();
+	}
+}
+
+void epic_leds_set_rocket(int led, uint8_t value)
+{
+	hwlock_acquire(HWLOCK_I2C);
+	pmic_set_led(led, value > 31 ? 31 : value);
+	hwlock_release(HWLOCK_I2C);
+}
+
+int epic_leds_get_rocket(int led)
+{
+	int ret = 0;
+
+	hwlock_acquire(HWLOCK_I2C);
+	ret = pmic_get_led(led);
+	hwlock_release(HWLOCK_I2C);
+	return ret;
+}
+
+static StaticTimer_t flash_timer_data[3];
+static TimerHandle_t flash_timer[] = { NULL, NULL, NULL };
+
+static void rocket_timer_callback(TimerHandle_t flash_timer)
+{
+	uint32_t id = (uint32_t)pvTimerGetTimerID(flash_timer);
+	epic_leds_set_rocket(id, 0);
+}
+
+void epic_leds_flash_rocket(int led, uint8_t value, int millis)
+{
+	int ticks  = millis * (configTICK_RATE_HZ / 1000);
+	int32_t id = led;
+	if (flash_timer[id] == NULL) {
+		flash_timer[id] = xTimerCreateStatic(
+			"flashtimer",
+			ticks,
+			pdFALSE,
+			(void *)id,
+			rocket_timer_callback,
+			&flash_timer_data[id]
+		);
+		epic_leds_set_rocket(led, value);
+	}
+	epic_leds_set_rocket(led, value);
+	xTimerChangePeriod(flash_timer[id], ticks, 0);
+}
+void epic_set_flashlight(bool power)
+{
+	hwlock_acquire(HWLOCK_I2C);
+	leds_flashlight(power);
+	hwlock_release(HWLOCK_I2C);
+}
+
+void epic_leds_update(void)
+{
+	do_update();
+}
+
+void epic_leds_set_powersave(bool eco)
+{
+	hwlock_acquire(HWLOCK_I2C);
+	leds_powersave(eco);
+	hwlock_release(HWLOCK_I2C);
+}
+
+void epic_leds_set_gamma_table(uint8_t rgb_channel, uint8_t *gamma_table)
+{
+	leds_set_gamma_table(rgb_channel, gamma_table);
+}
+
+void epic_leds_clear_all(uint8_t r, uint8_t g, uint8_t b)
+{
+	for (int i = 0; i < NUM_LEDS; i++) {
+		if (i == PERSONAL_STATE_LED && personal_state_enabled())
+			continue;
+
+		leds_prep(i, r, g, b);
+	}
+
+	do_update();
+}

epicardium/modules/light_sensor.c → epicardium/drivers/light_sensor.c

 #include "epicardium.h"
-#include "modules/log.h"
+#include "os/core.h"
+#include "os/work_queue.h"
 #include "modules/modules.h"
 
 #include "mxc_config.h"
@@ -27,26 +28,32 @@ static int light_sensor_init()
 	return 0;
 }
 
-static void readAdcCallback()
+uint16_t epic_light_sensor_read()
 {
-	if (hwlock_acquire(HWLOCK_ADC, 0) != 0) {
-		/* Can't do much about this here ... Retry next time */
-		return;
-	}
+	hwlock_acquire(HWLOCK_ADC);
 
 	ADC_StartConvert(ADC_CH_7, 0, 0);
 	ADC_GetData(&last_value);
 
 	hwlock_release(HWLOCK_ADC);
+	return last_value;
+}
+
+static void workpoll(void *data)
+{
+	epic_light_sensor_read();
+}
+
+static void poll(TimerHandle_t xTimer)
+{
+	workqueue_schedule(workpoll, NULL);
 }
 
 int epic_light_sensor_run()
 {
 	int ret = 0;
 
-	if (hwlock_acquire(HWLOCK_ADC, pdMS_TO_TICKS(500)) != 0) {
-		return -EBUSY;
-	}
+	hwlock_acquire(HWLOCK_ADC);
 
 	light_sensor_init();
 
@@ -56,7 +63,7 @@ int epic_light_sensor_run()
 			READ_FREQ,
 			pdTRUE,
 			NULL,
-			readAdcCallback,
+			poll,
 			&poll_timer_buffer
 		);
 		// since &poll_timer_buffer is not NULL, xTimerCreateStatic should allways succeed, so

epicardium/modules/max30001.c → epicardium/drivers/max30001.c

@@ -9,17 +9,14 @@
 
 #include "FreeRTOS.h"
 #include "task.h"
-#include "semphr.h"
 #include "queue.h"
 
-#include "api/interrupt-sender.h"
 #include "epicardium.h"
-#include "modules/log.h"
+#include "os/core.h"
 #include "modules/modules.h"
 #include "modules/stream.h"
-
-/* Ticks to wait when trying to acquire lock */
-#define LOCK_WAIT pdMS_TO_TICKS(MAX30001_MUTEX_WAIT_MS)
+#include "os/mutex.h"
+#include "user_core/interrupts.h"
 
 /* Interrupt Pin */
 static const gpio_cfg_t max30001_interrupt_pin = {
@@ -36,8 +33,7 @@ static const gpio_cfg_t analog_switch = {
 static TaskHandle_t max30001_task_id = NULL;
 
 /* MAX30001 Mutex */
-static StaticSemaphore_t max30001_mutex_data;
-static SemaphoreHandle_t max30001_mutex = NULL;
+static struct mutex max30001_mutex = { 0 };
 
 /* Stream */
 static struct stream_info max30001_stream;
@@ -54,15 +50,8 @@ int epic_max30001_enable_sensor(struct max30001_sensor_config *config)
 {
 	int result = 0;
 
-	result = hwlock_acquire(HWLOCK_SPI_ECG, pdMS_TO_TICKS(100));
-	if (result < 0) {
-		return result;
-	}
-
-	if (xSemaphoreTake(max30001_mutex, LOCK_WAIT) != pdTRUE) {
-		result = -EBUSY;
-		goto out_free_spi;
-	}
+	mutex_lock(&max30001_mutex);
+	hwlock_acquire(HWLOCK_SPI_ECG);
 
 	struct stream_info *stream = &max30001_stream;
 	;
@@ -97,9 +86,8 @@ int epic_max30001_enable_sensor(struct max30001_sensor_config *config)
 	result                 = SD_MAX30001_ECG;
 
 out_free_both:
-	xSemaphoreGive(max30001_mutex);
-out_free_spi:
 	hwlock_release(HWLOCK_SPI_ECG);
+	mutex_unlock(&max30001_mutex);
 	return result;
 }
 
@@ -107,15 +95,8 @@ int epic_max30001_disable_sensor(void)
 {
 	int result = 0;
 
-	result = hwlock_acquire(HWLOCK_SPI_ECG, pdMS_TO_TICKS(100));
-	if (result < 0) {
-		return result;
-	}
-
-	if (xSemaphoreTake(max30001_mutex, LOCK_WAIT) != pdTRUE) {
-		result = -EBUSY;
-		goto out_free_spi;
-	}
+	mutex_lock(&max30001_mutex);
+	hwlock_acquire(HWLOCK_SPI_ECG);
 
 	struct stream_info *stream = &max30001_stream;
 	result                     = stream_deregister(SD_MAX30001_ECG, stream);
@@ -134,9 +115,8 @@ int epic_max30001_disable_sensor(void)
 
 	result = 0;
 out_free_both:
-	xSemaphoreGive(max30001_mutex);
-out_free_spi:
 	hwlock_release(HWLOCK_SPI_ECG);
+	mutex_unlock(&max30001_mutex);
 	return result;
 }
 
@@ -155,16 +135,18 @@ static void max30001_handle_samples(int16_t *sensor_data, int16_t n)
 
 	while (n--) {
 		uint16_t data = -*sensor_data++;
-		if (xQueueSend(
-			    max30001_stream.queue,
-			    &data,
-			    MAX30001_MUTEX_WAIT_MS) != pdTRUE) {
-			LOG_WARN(
-				"max30001",
-				"queue full"); // TODO; handle queue full
+
+		/* Discard overflow.  See discussion in !316. */
+		if (xQueueSend(max30001_stream.queue, &data, 0) != pdTRUE) {
+			if (!max30001_stream.was_full) {
+				LOG_WARN("max30001", "queue full");
+			}
+			max30001_stream.was_full = true;
+		} else {
+			max30001_stream.was_full = false;
 		}
 	}
-	api_interrupt_trigger(EPIC_INT_MAX30001_ECG);
+	interrupt_trigger(EPIC_INT_MAX30001_ECG);
 }
 
 /***** Functions *****/
@@ -301,23 +283,16 @@ static int max30001_fetch_fifo(void)
 {
 	int result = 0;
 
-	result = hwlock_acquire(HWLOCK_SPI_ECG, pdMS_TO_TICKS(100));
-	if (result < 0) {
-		return result;
-	}
-
-	if (xSemaphoreTake(max30001_mutex, LOCK_WAIT) != pdTRUE) {
-		result = -EBUSY;
-		goto out_free_spi;
-	}
+	mutex_lock(&max30001_mutex);
+	hwlock_acquire(HWLOCK_SPI_ECG);
 
 	uint32_t ecgFIFO, readECGSamples, ETAG[32], status;
 	int16_t ecgSample[32];
-	const int EINT_STATUS_MASK       = 1 << 23;
-	const int FIFO_OVF_MASK          = 0x7;
-	const int FIFO_VALID_SAMPLE_MASK = 0x0;
-	const int FIFO_FAST_SAMPLE_MASK  = 0x1;
-	const int ETAG_BITS_MASK         = 0x7;
+	const uint32_t EINT_STATUS_MASK       = 1 << 23;
+	const uint32_t FIFO_OVF_MASK          = 0x7;
+	const uint32_t FIFO_VALID_SAMPLE_MASK = 0x0;
+	const uint32_t FIFO_FAST_SAMPLE_MASK  = 0x1;
+	const uint32_t ETAG_BITS_MASK         = 0x7;
 
 	status = ecg_read_reg(STATUS); // Read the STATUS register
 
@@ -347,9 +322,8 @@ static int max30001_fetch_fifo(void)
 		max30001_handle_samples(ecgSample, readECGSamples);
 	}
 
-	xSemaphoreGive(max30001_mutex);
-out_free_spi:
 	hwlock_release(HWLOCK_SPI_ECG);
+	mutex_unlock(&max30001_mutex);
 	return result;
 }
 
@@ -372,24 +346,15 @@ static void max300001_interrupt_callback(void *_)
 
 void max30001_mutex_init(void)
 {
-	max30001_mutex = xSemaphoreCreateMutexStatic(&max30001_mutex_data);
+	mutex_create(&max30001_mutex);
 }
 
 void vMAX30001Task(void *pvParameters)
 {
 	max30001_task_id = xTaskGetCurrentTaskHandle();
 
-	int lockret = hwlock_acquire(HWLOCK_SPI_ECG, pdMS_TO_TICKS(100));
-	if (lockret < 0) {
-		LOG_CRIT("max30001", "Failed to acquire SPI lock!");
-		vTaskDelay(portMAX_DELAY);
-	}
-
-	/* Take Mutex during initialization, just in case */
-	if (xSemaphoreTake(max30001_mutex, 0) != pdTRUE) {
-		LOG_CRIT("max30001", "Failed to acquire MAX30001 mutex!");
-		vTaskDelay(portMAX_DELAY);
-	}
+	mutex_lock(&max30001_mutex);
+	hwlock_acquire(HWLOCK_SPI_ECG);
 
 	/* Install interrupt callback */
 	GPIO_Config(&max30001_interrupt_pin);
@@ -410,20 +375,15 @@ void vMAX30001Task(void *pvParameters)
 	GPIO_Config(&analog_switch);
 	GPIO_OutClr(&analog_switch); // Wrist
 
-	xSemaphoreGive(max30001_mutex);
 	hwlock_release(HWLOCK_SPI_ECG);
+	mutex_unlock(&max30001_mutex);
 
 	/* ----------------------------------------- */
 
 	while (1) {
 		if (max30001_sensor_active) {
 			int ret = max30001_fetch_fifo();
-			if (ret == -EBUSY) {
-				LOG_WARN(
-					"max30001", "Could not acquire mutex?"
-				);
-				continue;
-			} else if (ret < 0) {
+			if (ret < 0) {
 				LOG_ERR("max30001", "Unknown error: %d", -ret);
 			}
 		}

epicardium/drivers/max86150.c

+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include "max86150.h"
+#include "epicardium.h"
+#include "os/core.h"
+#include "modules/stream.h"
+#include "gpio.h"
+#include "pmic.h"
+#include "user_core/interrupts.h"
+
+#include "FreeRTOS.h"
+#include "task.h"
+#include "queue.h"
+
+#include "modules/modules.h"
+
+static const gpio_cfg_t max86150_interrupt_pin = {
+	PORT_1, PIN_13, GPIO_FUNC_IN, GPIO_PAD_PULL_UP
+};
+
+/* MAX86150 Task ID */
+static TaskHandle_t max86150_task_id = NULL;
+
+/* MAX86150 Mutex */
+static struct mutex max86150_mutex = { 0 };
+
+/* Stream */
+static struct stream_info max86150_stream;
+
+/* Active */
+static bool max86150_sensor_active = false;
+
+int epic_max86150_enable_sensor(
+	struct max86150_sensor_config *config, size_t config_size
+) {
+	int result = 0;
+
+	if (sizeof(struct max86150_sensor_config) != config_size) {
+		return -EINVAL;
+	}
+
+	mutex_lock(&max86150_mutex);
+	hwlock_acquire(HWLOCK_I2C);
+
+	struct stream_info *stream = &max86150_stream;
+	stream->item_size          = sizeof(struct max86150_sensor_data);
+	stream->queue =
+		xQueueCreate(config->sample_buffer_len, stream->item_size);
+	if (stream->queue == NULL) {
+		result = -ENOMEM;
+		goto out_free;
+	}
+
+	uint8_t ppg_sample_rate;
+
+	if (config->ppg_sample_rate == 10) {
+		ppg_sample_rate = MAX86150_PPG_SAMPLERATE_10;
+	} else if (config->ppg_sample_rate == 20) {
+		ppg_sample_rate = MAX86150_PPG_SAMPLERATE_20;
+	} else if (config->ppg_sample_rate == 50) {
+		ppg_sample_rate = MAX86150_PPG_SAMPLERATE_50;
+	} else if (config->ppg_sample_rate == 84) {
+		ppg_sample_rate = MAX86150_PPG_SAMPLERATE_84;
+	} else if (config->ppg_sample_rate == 100) {
+		ppg_sample_rate = MAX86150_PPG_SAMPLERATE_100;
+	} else if (config->ppg_sample_rate == 200) {
+		ppg_sample_rate = MAX86150_PPG_SAMPLERATE_200;
+	} else if (config->ppg_sample_rate == 400) {
+		ppg_sample_rate = MAX86150_PPG_SAMPLERATE_400;
+	} else {
+		result = -EINVAL;
+		goto out_free;
+	}
+
+	result = stream_register(SD_MAX86150, stream);
+	if (result < 0) {
+		vQueueDelete(stream->queue);
+		goto out_free;
+	}
+
+	bool begin_result = max86150_begin();
+	if (!begin_result) {
+		result = -ENODEV;
+		vQueueDelete(stream->queue);
+		goto out_free;
+	}
+
+	max86150_setup(ppg_sample_rate);
+	max86150_get_int1();
+	max86150_get_int2();
+
+	max86150_sensor_active = true;
+	result                 = SD_MAX86150;
+
+out_free:
+	hwlock_release(HWLOCK_I2C);
+	mutex_unlock(&max86150_mutex);
+	return result;
+}
+
+int epic_max86150_disable_sensor(void)
+{
+	int result = 0;
+
+	mutex_lock(&max86150_mutex);
+	hwlock_acquire(HWLOCK_I2C);
+
+	max86150_shut_down();
+	max86150_sensor_active = false;
+
+	struct stream_info *stream = &max86150_stream;
+	result                     = stream_deregister(SD_MAX86150, stream);
+	if (result == 0) {
+		vQueueDelete(stream->queue);
+		stream->queue = NULL;
+	}
+
+	hwlock_release(HWLOCK_I2C);
+	mutex_unlock(&max86150_mutex);
+	return result;
+}
+
+static int max86150_handle_sample(struct max86150_sensor_data *data)
+{
+	//LOG_INFO("max86150", "Sample! %ld, %ld, %ld", data->red, data->ir, data->ecg);
+
+	if (max86150_stream.queue == NULL) {
+		return -ESRCH;
+	}
+
+	/* Discard overflow.  See discussion in !316. */
+	if (xQueueSend(max86150_stream.queue, data, 0) != pdTRUE) {
+		if (!max86150_stream.was_full) {
+			LOG_WARN("max86150", "queue full");
+		}
+		max86150_stream.was_full = true;
+	} else {
+		max86150_stream.was_full = false;
+	}
+
+	return 0;
+}
+
+static int max86150_fetch_fifo(void)
+{
+	int result = 0;
+
+	mutex_lock(&max86150_mutex);
+	hwlock_acquire(HWLOCK_I2C);
+
+	struct max86150_sensor_data sample;
+
+	// There is a recommendation from Maxim not to read the entire FIFO, but rather a fixed number of samples.
+	// See https://os.mbed.com/users/laserdad/code/MAX86150_ECG_PPG//file/3c728f3d1f10/main.cpp/
+	// So we should not use max86150_check() but max86150_get_sample().
+	int n = 0;
+	while (max86150_get_sample(&sample.red, &sample.ir, &sample.ecg) > 0) {
+		n++;
+		result = max86150_handle_sample(&sample);
+		// stop in case of errors
+		if (result < 0) {
+			n = 0;
+			break;
+		}
+	}
+	hwlock_release(HWLOCK_I2C);
+	mutex_unlock(&max86150_mutex);
+
+	if (n > 0) {
+		interrupt_trigger(EPIC_INT_MAX86150);
+	}
+	//LOG_INFO("max86150", "%d", n);
+	return result;
+}
+
+/*
+ * Callback for the MAX86150 interrupt pin.  This callback is called from the
+ * SDK's GPIO interrupt driver, in interrupt context.
+ */
+static void max86150_interrupt_callback(void *_)
+{
+	BaseType_t xHigherPriorityTaskWoken = pdFALSE;
+
+	if (max86150_task_id != NULL) {
+		vTaskNotifyGiveFromISR(
+			max86150_task_id, &xHigherPriorityTaskWoken
+		);
+		portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
+	}
+}
+/* }}} */
+
+void max86150_mutex_init(void)
+{
+	mutex_create(&max86150_mutex);
+}
+
+void vMAX86150Task(void *pvParameters)
+{
+	max86150_task_id = xTaskGetCurrentTaskHandle();
+
+	mutex_lock(&max86150_mutex);
+	hwlock_acquire(HWLOCK_I2C);
+
+	/* Install interrupt callback */
+	GPIO_Config(&max86150_interrupt_pin);
+	GPIO_RegisterCallback(
+		&max86150_interrupt_pin, max86150_interrupt_callback, NULL
+	);
+	GPIO_IntConfig(
+		&max86150_interrupt_pin, GPIO_INT_EDGE, GPIO_INT_FALLING
+	);
+	GPIO_IntEnable(&max86150_interrupt_pin);
+	NVIC_SetPriority(
+		(IRQn_Type)MXC_GPIO_GET_IRQ(max86150_interrupt_pin.port), 2
+	);
+	NVIC_EnableIRQ(
+		(IRQn_Type)MXC_GPIO_GET_IRQ(max86150_interrupt_pin.port)
+	);
+
+	hwlock_release(HWLOCK_I2C);
+	mutex_unlock(&max86150_mutex);
+
+	/* ----------------------------------------- */
+
+	while (1) {
+		if (max86150_sensor_active) {
+			//LOG_INFO("max86150", "Interrupt!");
+			mutex_lock(&max86150_mutex);
+			hwlock_acquire(HWLOCK_I2C);
+
+			int i1 = max86150_get_int1();
+
+			hwlock_release(HWLOCK_I2C);
+			mutex_unlock(&max86150_mutex);
+
+			//LOG_INFO("max86150", "%d", i1);
+
+			if (i1 & 16) {
+				interrupt_trigger(EPIC_INT_MAX86150_PROX);
+			}
+
+			int ret = max86150_fetch_fifo();
+			if (ret < 0) {
+				LOG_ERR("max86150", "Unknown error: %d", -ret);
+			}
+		}
+		/*
+		 * Wait for interrupt.  After two seconds, fetch FIFO anyway
+		 *
+		 * In the future, reads using epic_stream_read() might also
+		 * trigger a FIFO fetch, from outside this task.
+		 */
+		ulTaskNotifyTake(pdTRUE, pdMS_TO_TICKS(2000));
+	}
+}

epicardium/drivers/meson.build

+driver_sources = files(
+  'bhi.c',
+  'bsec.c',
+  'bme680.c',
+  'buttons.c',
+  'gpio.c',
+  'leds.c',
+  'light_sensor.c',
+  'max86150.c',
+  'max30001.c',
+  'pmic.c',
+  'rtc.c',
+  'serial.c',
+  'sleep.c',
+  'rng.c',
+  'usb.c',
+  'vibra.c',
+  'watchdog.c',
+  'ws2812.c',
+
+  'display/lcd.c',
+  'display/api.c',
+  'display/init.c',
+)

epicardium/drivers/pmic.c

+#include "epicardium.h"
+#include "modules/modules.h"
+#include "drivers/drivers.h"
+#include "os/core.h"
+#include "os/config.h"
+#include "user_core/user_core.h"
+
+#include "card10.h"
+#include "pmic.h"
+#include "MAX77650-Arduino-Library.h"
+
+#include "max32665.h"
+#include "mxc_sys.h"
+#include "mxc_pins.h"
+#include "adc.h"
+
+#include "FreeRTOS.h"
+#include "task.h"
+#include "timers.h"
+
+#include <stdio.h>
+#include <string.h>
+
+/* Task ID for the pmic handler */
+static TaskHandle_t pmic_task_id = NULL;
+
+enum {
+	/* An irq was received, probably the power button */
+	PMIC_NOTIFY_IRQ = 1,
+	/* The timer has ticked and we should check the battery voltage again */
+	PMIC_NOTIFY_MONITOR = 2,
+};
+
+void pmic_interrupt_callback(void *_)
+{
+	BaseType_t xHigherPriorityTaskWoken = pdFALSE;
+	if (pmic_task_id != NULL) {
+		xTaskNotifyFromISR(
+			pmic_task_id,
+			PMIC_NOTIFY_IRQ,
+			eSetBits,
+			&xHigherPriorityTaskWoken
+		);
+		portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
+	}
+}
+
+int pmic_read_amux(enum pmic_amux_signal sig, float *result)
+{
+	int ret = 0;
+
+	if (sig > _PMIC_AMUX_MAX) {
+		return -EINVAL;
+	}
+
+	hwlock_acquire(HWLOCK_ADC);
+	hwlock_acquire(HWLOCK_I2C);
+
+	/* Select the correct channel for this measurement.  */
+	MAX77650_setMUX_SEL(sig);
+
+	/*
+	 * According to the datasheet, the voltage will stabilize within 0.3us.
+	 * Just to be sure, we'll wait a little longer.  In the meantime,
+	 * release the I2C mutex.
+	 */
+	hwlock_release(HWLOCK_I2C);
+
+	vTaskDelay(pdMS_TO_TICKS(5));
+	hwlock_acquire(HWLOCK_I2C);
+
+	uint16_t adc_data;
+	ADC_StartConvert(ADC_CH_0, 0, 0);
+	ADC_GetData(&adc_data);
+
+	/* Turn MUX back to neutral so it does not waste power.  */
+	MAX77650_setMUX_SEL(PMIC_AMUX_DISABLED);
+
+	/* Convert ADC measurement to SI Volts */
+	float adc_voltage = (float)adc_data / 1023.0f * 1.22f;
+
+	/*
+	 * Convert value according to PMIC formulas (Table 7)
+	 */
+	switch (sig) {
+	case PMIC_AMUX_CHGIN_U:
+		*result = adc_voltage / 0.167f;
+		break;
+	case PMIC_AMUX_CHGIN_I:
+		*result = adc_voltage / 2.632f;
+		break;
+	case PMIC_AMUX_BATT_U:
+		*result = adc_voltage / 0.272f;
+		break;
+	case PMIC_AMUX_BATT_CHG_I:
+		*result = adc_voltage / 1.25f;
+		break;
+	case PMIC_AMUX_BATT_NULL_I:
+	case PMIC_AMUX_THM_U:
+	case PMIC_AMUX_TBIAS_U:
+	case PMIC_AMUX_AGND_U:
+		*result = adc_voltage;
+		break;
+	case PMIC_AMUX_SYS_U:
+		*result = adc_voltage / 0.26f;
+		break;
+	default:
+		ret = -EINVAL;
+	}
+
+	hwlock_release(HWLOCK_I2C);
+	hwlock_release(HWLOCK_ADC);
+
+	return ret;
+}
+
+/*
+ * Read the interrupt flag register and handle all interrupts which the PMIC has
+ * sent.  In most cases this will be the buttons.
+ */
+static uint8_t pmic_poll_interrupts(void)
+{
+	hwlock_acquire(HWLOCK_I2C);
+
+	uint8_t int_flag = MAX77650_getINT_GLBL();
+	hwlock_release(HWLOCK_I2C);
+
+	/* TODO: Remove when all interrupts are handled */
+	if (int_flag & ~(MAX77650_INT_nEN_F | MAX77650_INT_nEN_R)) {
+		LOG_WARN("pmic", "Unhandled PMIC Interrupt: %x", int_flag);
+	}
+
+	return int_flag;
+}
+
+__attribute__((noreturn)) static void pmic_die(float u_batt)
+{
+	/* Stop core 1 */
+	core1_stop();
+
+	/* Grab the screen */
+	disp_forcelock();
+
+	/* Turn it on in case it was off */
+	epic_disp_backlight(100);
+
+	/* Draw an error screen */
+	epic_disp_clear(0x0000);
+
+	epic_disp_print(0, 0, " Battery", 0xffff, 0x0000);
+	epic_disp_print(0, 20, " critical", 0xffff, 0x0000);
+	epic_disp_print(0, 40, "  !!!!", 0xffff, 0x0000);
+	epic_disp_update();
+
+	/* Vibrate violently */
+	epic_vibra_set(true);
+
+	/* Wait a bit */
+	for (int i = 0; i < 50000000; i++)
+		__NOP();
+
+	/* We have some of headroom to keep the RTC going.
+	 * The battery protection circuit will shut down
+	 * the system at 3.0 V */
+
+	/* TODO: Wake-up when USB is attached again */
+	sleep_deepsleep();
+	card10_reset();
+}
+
+/*
+ * Check the battery voltage.  If it drops too low, turn card10 off.
+ */
+static void pmic_check_battery()
+{
+	float u_batt;
+	int res;
+
+	/**
+	 * 0 = uncertain, ask config
+	 * 1 = disabled
+	 * 2 = enabled
+	 */
+	static int pmic_do_battery_check = 0;
+
+	if (pmic_do_battery_check == 0) {
+		if (config_get_boolean_with_default("battery_check", true)) {
+			pmic_do_battery_check = 2;
+		} else {
+			pmic_do_battery_check = 1;
+			LOG_WARN(
+				"pmic",
+				"Battery check was disabled by config!"
+			);
+		}
+	}
+
+	if (pmic_do_battery_check == 1) {
+		/* Disabled, ignore */
+		return;
+	}
+
+	res = pmic_read_amux(PMIC_AMUX_BATT_U, &u_batt);
+	if (res < 0) {
+		LOG_ERR("pmic",
+			"Failed reading battery voltage: %s (%d)",
+			strerror(-res),
+			res);
+		return;
+	}
+
+	LOG_DEBUG(
+		"pmic",
+		"Battery is at %d.%03d V",
+		(int)u_batt,
+		(int)(u_batt * 1000.0) % 1000
+	);
+
+	if (u_batt < BATTERY_CRITICAL) {
+		pmic_die(u_batt);
+	}
+}
+
+/*
+ * API-call for battery voltage
+ */
+int epic_read_battery_voltage(float *result)
+{
+	return pmic_read_amux(PMIC_AMUX_BATT_U, result);
+}
+
+/*
+ * API-call for battery current
+ */
+int epic_read_battery_current(float *result)
+{
+	return pmic_read_amux(PMIC_AMUX_BATT_CHG_I, result);
+}
+
+/*
+ * API-call for charge voltage
+ */
+int epic_read_chargein_voltage(float *result)
+{
+	return pmic_read_amux(PMIC_AMUX_CHGIN_U, result);
+}
+
+/*
+ * API-call for charge voltage
+ */
+int epic_read_chargein_current(float *result)
+{
+	return pmic_read_amux(PMIC_AMUX_BATT_CHG_I, result);
+}
+
+/*
+ * API-call for system voltage
+ */
+int epic_read_system_voltage(float *result)
+{
+	return pmic_read_amux(PMIC_AMUX_SYS_U, result);
+}
+
+/*
+ * API-call for thermistor voltage
+ *
+ * Thermistor is as 10k at room temperature,
+ * voltage divided with another 10k.
+ * (50% V_bias at room temperature)
+ */
+int epic_read_thermistor_voltage(float *result)
+{
+	return pmic_read_amux(PMIC_AMUX_THM_U, result);
+}
+
+static StaticTimer_t pmic_timer_data;
+static void vPmicTimerCb(TimerHandle_t xTimer)
+{
+	/*
+	 * Tell the PMIC task to check the battery again.
+	 */
+	xTaskNotify(pmic_task_id, PMIC_NOTIFY_MONITOR, eSetBits);
+}
+
+void vPmicTask(void *pvParameters)
+{
+	pmic_task_id       = xTaskGetCurrentTaskHandle();
+	uint8_t interrupts = 0;
+	uint32_t reason    = 0;
+
+	ADC_Init(0x9, NULL);
+	GPIO_Config(&gpio_cfg_adc0);
+
+	TickType_t button_start_tick = 0;
+
+	pmic_check_battery();
+
+	TimerHandle_t pmic_timer = xTimerCreateStatic(
+		"PMIC Timer",
+		pdMS_TO_TICKS(60 * 1000),
+		pdTRUE,
+		NULL,
+		vPmicTimerCb,
+		&pmic_timer_data
+	);
+	if (pmic_timer == NULL) {
+		LOG_CRIT("pmic", "Could not create timer.");
+		vTaskDelay(portMAX_DELAY);
+	}
+	xTimerStart(pmic_timer, 0);
+
+	/* Clear all pending interrupts. */
+	pmic_poll_interrupts();
+
+	while (1) {
+		interrupts |= pmic_poll_interrupts();
+		if (interrupts == 0) {
+			reason |= ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
+		}
+
+		/* New interrupts */
+		if (reason & PMIC_NOTIFY_IRQ) {
+			reason ^= PMIC_NOTIFY_IRQ;
+			interrupts |= pmic_poll_interrupts();
+		}
+
+		if (interrupts & MAX77650_INT_nEN_R) {
+			/* Ignored in this state */
+			/* This can happen if the button is pressed
+			 * during boot and released now. */
+			interrupts ^= MAX77650_INT_nEN_R; /* Mark as handled. */
+		}
+
+		if (interrupts & MAX77650_INT_nEN_F) {
+			/* Button was pressed */
+			interrupts ^= MAX77650_INT_nEN_F; /* Mark as handled. */
+
+			button_start_tick = xTaskGetTickCount();
+			while (true) {
+				TickType_t duration =
+					xTaskGetTickCount() - button_start_tick;
+
+				if (duration > pdMS_TO_TICKS(1000)) {
+					disp_forcelock();
+					disp_ctx_reinit();
+
+					/* Turn it on in case it was off */
+					epic_disp_backlight(100);
+
+					epic_disp_clear(0x0000);
+
+					char buf[20];
+					sprintf(buf,
+						"Off in %d",
+						7 - (int)(duration + 500) /
+								1000);
+					epic_disp_print(
+						0,
+						0,
+						"Sleep zZz..",
+						0xffff,
+						0x0000
+					);
+					epic_disp_print(
+						0, 25, buf, 0xf000, 0x0000
+					);
+					epic_disp_print(
+						0,
+						50,
+						"   Reset ->",
+						0xffff,
+						0x0000
+					);
+					epic_disp_update();
+				}
+
+				if (duration >= pdMS_TO_TICKS(1000)) {
+					if (epic_buttons_read(
+						    BUTTON_RIGHT_TOP)) {
+						disp_forcelock();
+						disp_ctx_reinit();
+
+						/* Turn it on in case it was off */
+						epic_disp_backlight(100);
+
+						epic_disp_clear(0x0000);
+						epic_disp_print(
+							55,
+							30,
+							"Reset!",
+							0xf800,
+							0x0000
+						);
+						epic_disp_update();
+
+						serial_return_to_synchronous();
+						LOG_WARN(
+							"pmic",
+							"Resetting ..."
+						);
+						card10_reset();
+					}
+				}
+
+				if (interrupts & MAX77650_INT_nEN_R) {
+					/* Button is released */
+					interrupts ^=
+						MAX77650_INT_nEN_R; /* Mark as handled. */
+
+					if (duration < pdMS_TO_TICKS(1000)) {
+						return_to_menu();
+					}
+
+					if (duration > pdMS_TO_TICKS(1000)) {
+						serial_return_to_synchronous();
+						LOG_WARN("pmic", "Poweroff");
+						sleep_deepsleep();
+						card10_reset();
+					}
+					break;
+				}
+
+				reason |= ulTaskNotifyTake(
+					pdTRUE, pdMS_TO_TICKS(200)
+				);
+				if (reason & PMIC_NOTIFY_IRQ) {
+					/* New interrupts */
+					reason ^= PMIC_NOTIFY_IRQ;
+					interrupts |= pmic_poll_interrupts();
+				}
+			}
+		}
+
+		if (reason & PMIC_NOTIFY_MONITOR) {
+			reason ^= PMIC_NOTIFY_MONITOR;
+			pmic_check_battery();
+		}
+	}
+}

epicardium/drivers/rng.c

+#include "epicardium.h"
+#include "modules/modules.h"
+#include "drivers/drivers.h"
+
+#include "MAX77650-Arduino-Library.h"
+#include "tiny-AES-c/aes.h"
+#include "SHA256/mark2/sha256.h"
+
+#include "mxc_sys.h"
+#include "adc.h"
+#include "mxc_delay.h"
+#include "rtc.h"
+#include "trng.h"
+
+#include <string.h>
+
+static struct AES_ctx aes_ctx;
+
+int epic_trng_read(uint8_t *dest, size_t size)
+{
+	if (dest == NULL)
+		return -EFAULT;
+
+	TRNG_Init(NULL);
+	TRNG_Read(MXC_TRNG, dest, size);
+
+	return 0;
+}
+
+int epic_csprng_read(uint8_t *dest, size_t size)
+{
+	if (size >= AES_BLOCKLEN) {
+		int block_count = size / AES_BLOCKLEN;
+		AES_CTR_xcrypt_buffer(
+			&aes_ctx, dest, block_count * AES_BLOCKLEN
+		);
+		size -= block_count * AES_BLOCKLEN;
+		dest += block_count * AES_BLOCKLEN;
+	}
+
+	if (size > 0) {
+		uint8_t out[AES_BLOCKLEN];
+		AES_CTR_xcrypt_buffer(&aes_ctx, out, sizeof(out));
+		memcpy(dest, out, size);
+	}
+
+	return 0;
+}
+
+void rng_init(void)
+{
+	uint8_t key[AES_BLOCKLEN];
+	uint8_t iv[AES_BLOCKLEN];
+	uint8_t hash[32];
+	sha256_context ctx;
+	int i;
+
+	sha256_init(&ctx);
+
+	/* Seed from TRNG.
+	 * Takes about 10 ms. */
+	for (i = 0; i < 256; i++) {
+		uint8_t entropy[AES_BLOCKLEN];
+		epic_trng_read(entropy, AES_BLOCKLEN);
+		sha256_hash(&ctx, entropy, AES_BLOCKLEN);
+	}
+
+	// Seed from RTC
+	uint32_t sec, subsec;
+	while (RTC_GetTime(&sec, &subsec) == E_BUSY) {
+		mxc_delay(4000);
+	}
+	sha256_hash(&ctx, &sec, sizeof(sec));
+	sha256_hash(&ctx, &subsec, sizeof(subsec));
+
+	// Seed from SysTick
+	uint32_t systick = SysTick->VAL;
+	sha256_hash(&ctx, &systick, sizeof(systick));
+
+	/* Seed from ADC.
+	 * Takes about 50 ms */
+	ADC_Init(0x9, NULL);
+	GPIO_Config(&gpio_cfg_adc0);
+	MAX77650_setMUX_SEL(PMIC_AMUX_BATT_U);
+	for (i = 0; i < 256; i++) {
+		uint16_t adc_data;
+		ADC_StartConvert(ADC_CH_0, 0, 0);
+		ADC_GetData(&adc_data);
+		sha256_hash(&ctx, &adc_data, sizeof(adc_data));
+	}
+	MAX77650_setMUX_SEL(PMIC_AMUX_DISABLED);
+
+	sha256_done(&ctx, hash);
+	memcpy(key, hash, AES_BLOCKLEN);
+	memcpy(iv, hash + AES_BLOCKLEN, AES_BLOCKLEN);
+	AES_init_ctx_iv(&aes_ctx, key, iv);
+}

epicardium/drivers/rtc.c

+#include "epicardium.h"
+#include "os/core.h"
+#include "modules/modules.h"
+#include "user_core/interrupts.h"
+
+#include "FreeRTOS.h"
+#include "task.h"
+
+#include "rtc.h"
+
+#include <stdint.h>
+
+uint64_t monotonic_offset = 0;
+
+uint32_t epic_rtc_get_monotonic_seconds(void)
+{
+	return epic_rtc_get_seconds() + monotonic_offset / 1000ULL;
+}
+
+uint64_t epic_rtc_get_monotonic_milliseconds(void)
+{
+	return epic_rtc_get_milliseconds() + monotonic_offset;
+}
+
+uint32_t epic_rtc_get_seconds(void)
+{
+	uint32_t sec, subsec;
+
+	/*
+	 * TODO:  Find out what causes the weird behavior of this function.  The
+	 *        time needed for this call seems to depend on the frequency at
+	 *        which it is called.
+	 */
+	while (RTC_GetTime(&sec, &subsec) == E_BUSY) {
+		vTaskDelay(pdMS_TO_TICKS(4));
+	}
+
+	return sec;
+}
+
+uint64_t epic_rtc_get_milliseconds(void)
+{
+	uint32_t sec, subsec;
+
+	while (RTC_GetTime(&sec, &subsec) == E_BUSY) {
+		vTaskDelay(pdMS_TO_TICKS(4));
+	}
+
+	// Without the bias of 999 (0.24 milliseconds), this decoding function is
+	// numerically unstable:
+	//
+	// Encoding 5 milliseconds into 20 subsecs (using the encoding function in
+	// epic_rtc_set_milliseconds) and decoding it without the bias of 999 yields
+	// 4 milliseconds.
+	//
+	// The following invariants should hold when encoding / decoding from and to
+	// milliseconds / subseconds:
+	//
+	// - 0 <= encode(ms) < 4096 for 0 <= ms < 1000
+	// - decode(encode(ms)) == ms for 0 <= ms < 1000
+	// - 0 <= decode(subsec) < 1000 for 0 <= subsec < 4096
+	//
+	// These invariants were proven experimentally.
+	return (subsec * 1000ULL + 999ULL) / 4096 + sec * 1000ULL;
+}
+
+void epic_rtc_set_milliseconds(uint64_t milliseconds)
+{
+	uint32_t sec, subsec;
+	uint64_t old_milliseconds, diff;
+
+	old_milliseconds = epic_rtc_get_milliseconds();
+
+	sec    = milliseconds / 1000;
+	subsec = (milliseconds % 1000);
+	subsec *= 4096;
+	subsec /= 1000;
+
+	while (RTC_Init(MXC_RTC, sec, subsec, NULL) == E_BUSY)
+		;
+	while (RTC_EnableRTCE(MXC_RTC) == E_BUSY)
+		;
+
+	diff = old_milliseconds - milliseconds;
+	monotonic_offset += diff;
+}
+
+/* We need to use interrupt_trigger_unsafe() here */
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+void RTC_IRQHandler(void)
+{
+	int flags = RTC_GetFlags();
+
+	if (flags & MXC_F_RTC_CTRL_ALDF) {
+		RTC_ClearFlags(MXC_F_RTC_CTRL_ALDF);
+		interrupt_trigger_unsafe(EPIC_INT_RTC_ALARM);
+	} else {
+		LOG_WARN("rtc", "Unknown IRQ caught!");
+		/* Disable IRQ so it does not retrigger */
+		NVIC_DisableIRQ(RTC_IRQn);
+	}
+}
+#pragma GCC diagnostic pop
+
+int epic_rtc_schedule_alarm(uint32_t timestamp)
+{
+	int res;
+
+	/*
+	 * Check if the timestamp lies in the past and if so, trigger
+	 * immediately.
+	 */
+	if (epic_rtc_get_seconds() >= timestamp) {
+		interrupt_trigger(EPIC_INT_RTC_ALARM);
+		return 0;
+	}
+
+	NVIC_EnableIRQ(RTC_IRQn);
+
+	while ((res = RTC_SetTimeofdayAlarm(MXC_RTC, timestamp)) == E_BUSY)
+		;
+
+	if (res != E_SUCCESS) {
+		return -EINVAL;
+	}
+
+	return 0;
+}

epicardium/drivers/serial.c

+#include "epicardium.h"
+#include "os/core.h"
+#include "modules/modules.h"
+#include "drivers/drivers.h"
+#include "user_core/interrupts.h"
+
+#include "max32665.h"
+#include "usb/cdcacm.h"
+#include "uart.h"
+
+#include "FreeRTOS.h"
+#include "task.h"
+#include "queue.h"
+#include "stream_buffer.h"
+
+#include <stdint.h>
+#include <stdio.h>
+
+/* The serial console in use (UART0) */
+extern mxc_uart_regs_t *ConsoleUart;
+
+/* Task ID for the serial handler */
+TaskHandle_t serial_task_id = NULL;
+
+/* Read queue, filled by both UART and CDCACM */
+static QueueHandle_t read_queue;
+/* Stream Buffer for handling all writes to serial */
+static StreamBufferHandle_t write_stream_buffer = NULL;
+
+void serial_init()
+{
+	/* Setup read queue */
+	static uint8_t buffer[sizeof(char) * SERIAL_READ_BUFFER_SIZE];
+	static StaticQueue_t read_queue_data;
+	read_queue = xQueueCreateStatic(
+		SERIAL_READ_BUFFER_SIZE, sizeof(char), buffer, &read_queue_data
+	);
+
+	/* Setup write queue */
+	static uint8_t ucWrite_stream_buffer[SERIAL_WRITE_STREAM_BUFFER_SIZE];
+	static StaticStreamBuffer_t xStream_buffer_struct;
+	write_stream_buffer = xStreamBufferCreateStatic(
+		sizeof(ucWrite_stream_buffer),
+		1,
+		ucWrite_stream_buffer,
+		&xStream_buffer_struct
+	);
+}
+
+void serial_return_to_synchronous()
+{
+	write_stream_buffer = NULL;
+}
+
+static void write_str_(const char *str, size_t length)
+{
+	if (length == 0) {
+		return;
+	}
+
+	/*
+	 * Check if the stream buffer is even initialized yet
+	 */
+	if (write_stream_buffer == NULL) {
+		UART_Write(ConsoleUart, (uint8_t *)str, length);
+		cdcacm_write((uint8_t *)str, length);
+		return;
+	}
+
+	if (xPortIsInsideInterrupt()) {
+		BaseType_t resched1 = pdFALSE;
+		BaseType_t resched2 = pdFALSE;
+
+		/*
+		 * Enter a critial section so no other task can write to the
+		 * stream buffer.
+		 */
+		uint32_t basepri = __get_BASEPRI();
+		taskENTER_CRITICAL_FROM_ISR();
+
+		xStreamBufferSendFromISR(
+			write_stream_buffer, str, length, &resched1
+		);
+
+		taskEXIT_CRITICAL_FROM_ISR(basepri);
+
+		if (serial_task_id != NULL) {
+			xTaskNotifyFromISR(
+				serial_task_id,
+				SERIAL_WRITE_NOTIFY,
+				eSetBits,
+				&resched2
+			);
+		}
+
+		/* Yield if this write woke up a higher priority task */
+		portYIELD_FROM_ISR(resched1 || resched2);
+	} else {
+		size_t bytes_sent = 0;
+		size_t index      = 0;
+		do {
+			taskENTER_CRITICAL();
+			/*
+			 * Wait time needs to be zero, because we are in a
+			 * critical section.
+			 */
+			bytes_sent = xStreamBufferSend(
+				write_stream_buffer,
+				&str[index],
+				length - index,
+				0
+			);
+			index += bytes_sent;
+			taskEXIT_CRITICAL();
+			if (serial_task_id != NULL) {
+				xTaskNotify(
+					serial_task_id,
+					SERIAL_WRITE_NOTIFY,
+					eSetBits
+				);
+				if (bytes_sent == 0) {
+					vTaskDelay(1);
+				} else {
+					portYIELD();
+				}
+			}
+		} while (index < length);
+	}
+}
+
+/*
+ * API-call to write a string.  Output goes to CDCACM, UART and BLE
+ *
+ * This is user data from core 1.
+ */
+void epic_uart_write_str(const char *str, size_t length)
+{
+	/* Make sure that we are not in an interrupt when talking to BLE.
+	 * Should not be the case if this is called from core 1
+	 * anyways. */
+	if (!xPortIsInsideInterrupt()) {
+		ble_uart_write((uint8_t *)str, length);
+	}
+	write_str_(str, length);
+}
+
+static void serial_flush_from_isr(void)
+{
+	uint8_t rx_data[32];
+	size_t received_bytes;
+
+	BaseType_t resched = pdFALSE;
+	BaseType_t woken   = pdFALSE;
+
+	uint32_t basepri = __get_BASEPRI();
+	taskENTER_CRITICAL_FROM_ISR();
+
+	do {
+		received_bytes = xStreamBufferReceiveFromISR(
+			write_stream_buffer,
+			(void *)rx_data,
+			sizeof(rx_data),
+			&woken
+		);
+		resched |= woken;
+
+		if (received_bytes == 0) {
+			break;
+		}
+
+		/*
+		 * The SDK-driver for UART is not reentrant
+		 * which means we need to perform UART writes
+		 * in a critical section.
+		 */
+
+		UART_Write(ConsoleUart, (uint8_t *)&rx_data, received_bytes);
+	} while (received_bytes > 0);
+
+	taskEXIT_CRITICAL_FROM_ISR(basepri);
+
+	portYIELD_FROM_ISR(resched);
+}
+
+static void serial_flush_from_thread(void)
+{
+	uint8_t rx_data[32];
+	size_t received_bytes;
+
+	do {
+		taskENTER_CRITICAL();
+		received_bytes = xStreamBufferReceive(
+			write_stream_buffer,
+			(void *)rx_data,
+			sizeof(rx_data),
+			0
+		);
+		taskEXIT_CRITICAL();
+
+		if (received_bytes == 0) {
+			break;
+		}
+
+		/*
+		 * The SDK-driver for UART is not reentrant
+		 * which means we need to perform UART writes
+		 * in a critical section.
+		 */
+		taskENTER_CRITICAL();
+		UART_Write(ConsoleUart, (uint8_t *)&rx_data, received_bytes);
+		taskEXIT_CRITICAL();
+
+		cdcacm_write((uint8_t *)&rx_data, received_bytes);
+	} while (received_bytes > 0);
+}
+
+/*
+ * Flush all characters which are currently waiting to be printed.
+ *
+ * If this function is called from an ISR, it will only flush to hardware UART
+ * while a call from thread mode will flush to UART, CDC-ACM, and BLE Serial.
+ */
+void serial_flush(void)
+{
+	if (xPortIsInsideInterrupt()) {
+		serial_flush_from_isr();
+	} else {
+		serial_flush_from_thread();
+	}
+}
+
+/*
+ * API-call to read a character from the queue.
+ */
+int epic_uart_read_char(void)
+{
+	char chr;
+	if (xQueueReceive(read_queue, &chr, 0) == pdTRUE) {
+		return (int)chr;
+	}
+	return (-1);
+}
+
+/*
+ * API-call to read data from the queue.
+ */
+int epic_uart_read_str(char *buf, size_t cnt)
+{
+	size_t i = 0;
+
+	for (i = 0; i < cnt; i++) {
+		if (xQueueReceive(read_queue, &buf[i], 0) != pdTRUE) {
+			break;
+		}
+	}
+
+	return i;
+}
+
+/*
+ * Write a string from epicardium. Output goes to CDCACM and UART
+ *
+ * This mainly log data from epicardium, not user date from core 1.
+ */
+long _write_epicardium(int fd, const char *buf, size_t cnt)
+{
+	/*
+	 * Only print one line at a time.  Insert `\r` between lines so they are
+	 * properly displayed on the serial console.
+	 */
+	size_t i, last = 0;
+	for (i = 0; i < cnt; i++) {
+		if (buf[i] == '\n') {
+			write_str_(&buf[last], i - last);
+			write_str_("\r", 1);
+			last = i;
+		}
+	}
+	write_str_(&buf[last], cnt - last);
+	return cnt;
+}
+
+/* Interrupt handler needed for SDK UART implementation */
+void UART0_IRQHandler(void)
+{
+	UART_Handler(ConsoleUart);
+}
+
+static void uart_callback(uart_req_t *req, int error)
+{
+	BaseType_t xHigherPriorityTaskWoken = pdFALSE;
+	xTaskNotifyFromISR(
+		serial_task_id,
+		SERIAL_READ_NOTIFY,
+		eSetBits,
+		&xHigherPriorityTaskWoken
+	);
+	portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
+}
+
+void serial_enqueue_char(char chr)
+{
+	if (chr == 0x3) {
+		/* Control-C */
+		interrupt_trigger(EPIC_INT_CTRL_C);
+	}
+
+	if (xQueueSend(read_queue, &chr, 100) == errQUEUE_FULL) {
+		/* Queue overran, wait a bit */
+		vTaskDelay(portTICK_PERIOD_MS * 50);
+	}
+
+	interrupt_trigger(EPIC_INT_UART_RX);
+}
+
+void vSerialTask(void *pvParameters)
+{
+	serial_task_id = xTaskGetCurrentTaskHandle();
+
+	/* Setup UART interrupt */
+	NVIC_ClearPendingIRQ(UART0_IRQn);
+	NVIC_DisableIRQ(UART0_IRQn);
+	NVIC_SetPriority(UART0_IRQn, 6);
+	NVIC_EnableIRQ(UART0_IRQn);
+
+	unsigned char data;
+	uart_req_t read_req = {
+		.data     = &data,
+		.len      = 1,
+		.callback = uart_callback,
+	};
+
+	while (1) {
+		int ret = UART_ReadAsync(ConsoleUart, &read_req);
+		if (ret != E_NO_ERROR && ret != E_BUSY) {
+			LOG_ERR("serial", "error reading uart: %d", ret);
+			vTaskDelay(portMAX_DELAY);
+		}
+
+		ret = ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
+
+		if (ret & SERIAL_WRITE_NOTIFY) {
+			serial_flush_from_thread();
+		}
+
+		if (ret & SERIAL_READ_NOTIFY) {
+			if (read_req.num > 0) {
+				serial_enqueue_char(*read_req.data);
+			}
+
+			while (UART_NumReadAvail(ConsoleUart) > 0) {
+				serial_enqueue_char(UART_ReadByte(ConsoleUart));
+			}
+
+			while (cdcacm_num_read_avail() > 0) {
+				serial_enqueue_char(cdcacm_read());
+			}
+		}
+	}
+}

epicardium/drivers/sleep.c

+#include "epicardium.h"
+#include "modules/modules.h"
+#include "os/core.h"
+
+#include "card10.h"
+#include "simo.h"
+#include "lp.h"
+#include "max86150.h"
+#include "MAX77650-Arduino-Library.h"
+
+#include "bb_drv.h"
+
+#include "max32665.h"
+#include "mxc_sys.h"
+#include "mxc_pins.h"
+
+#include <stdint.h>
+#include <limits.h>
+
+/* Most code is taken and adapted rom EvKitExamples/LP/main.c */
+
+static uint32_t old_clkcn;
+static uint32_t old_perckcn0, old_perckcn1;
+
+void GPIOWAKE_IRQHandler(void)
+{
+	/* Nothing to do here */
+}
+
+static void switchToHIRC(void)
+{
+	MXC_GCR->clkcn &= ~(MXC_S_GCR_CLKCN_PSC_DIV128);
+	MXC_GCR->clkcn |= MXC_S_GCR_CLKCN_PSC_DIV4;
+	MXC_GCR->clkcn |= MXC_F_GCR_CLKCN_HIRC_EN;
+
+	MXC_SETFIELD(
+		MXC_GCR->clkcn,
+		MXC_F_GCR_CLKCN_CLKSEL,
+		MXC_S_GCR_CLKCN_CLKSEL_HIRC
+	);
+
+	while (!(MXC_GCR->clkcn & MXC_F_GCR_CLKCN_CKRDY))
+		; /* Wait for the clock switch to occur */
+
+	/* Disable the now unused 96 MHz clock */
+	MXC_GCR->clkcn &= ~(MXC_F_GCR_CLKCN_HIRC96M_EN);
+
+	SystemCoreClockUpdate();
+}
+
+static void deepsleep(void)
+{
+	SIMO_setVregO_B(810); /* Reduce VCOREB to 0.81 V */
+	LP_FastWakeupEnable();
+	LP_EnterDeepSleepMode();
+	SIMO_setVregO_B(1000); /* Restore VCOREB to 1 V */
+}
+
+static void turnOffClocks(void)
+{
+	old_perckcn0 = MXC_GCR->perckcn0;
+	old_perckcn1 = MXC_GCR->perckcn1;
+
+	/* Allow the USB Switch to be turned off in deepsleep and backup modes. */
+	/* TODO: should this be the default setting? */
+	LP_USBSWLPDisable();
+
+	/* Disable all peripheral clocks except GPIO0 (needed for interrupt wakeup) */
+	MXC_GCR->perckcn0 = 0xFFFFFFFE;
+	MXC_GCR->perckcn1 = 0xFFFFFFFF;
+}
+
+static void turnOnClocks(void)
+{
+	MXC_GCR->perckcn0 = old_perckcn0;
+	MXC_GCR->perckcn1 = old_perckcn1;
+}
+
+/*
+ * Move most GPIOs into a special low power state with the fact
+ * in mind that the external 3.3 V are switched off.
+ *
+ * E.g. this means that the SD card pins need to be pulled low
+ * to preven them from backfeeding into the 3.3 V rail via their
+ * external pull-up resistors.
+ *
+ * Pins needed to talk to the PMIC are left untouched.
+ * ECG AOUT and 32 kHz out as well.
+ */
+static void gpio_low_power(void)
+{
+	/* clang-format off */
+	const gpio_cfg_t pins_low_power[] = {
+		{ PORT_0, PIN_0, GPIO_FUNC_IN, GPIO_PAD_PULL_UP },      // FLash
+		{ PORT_0, PIN_1, GPIO_FUNC_IN, GPIO_PAD_PULL_UP },      // Flash
+		{ PORT_0, PIN_2, GPIO_FUNC_IN, GPIO_PAD_PULL_UP },      // Flash
+		{ PORT_0, PIN_3, GPIO_FUNC_IN, GPIO_PAD_PULL_UP },      // Flash
+		{ PORT_0, PIN_4, GPIO_FUNC_IN, GPIO_PAD_PULL_UP },      // Flash
+		{ PORT_0, PIN_5, GPIO_FUNC_IN, GPIO_PAD_PULL_UP },      // Flash
+		{ PORT_0, PIN_6, GPIO_FUNC_OUT, GPIO_PAD_NONE },        // I2C 3.3V
+		{ PORT_0, PIN_7, GPIO_FUNC_OUT, GPIO_PAD_NONE },        // I2C 3.3V
+		{ PORT_0, PIN_8, GPIO_FUNC_OUT, GPIO_PAD_NONE },        // Motor
+		{ PORT_0, PIN_9, GPIO_FUNC_IN, GPIO_PAD_PULL_UP },      // UART TX
+		{ PORT_0, PIN_10, GPIO_FUNC_IN, GPIO_PAD_PULL_UP },     // UART RX
+		{ PORT_0, PIN_11, GPIO_FUNC_IN, GPIO_PAD_PULL_DOWN },   // BMA400 interrupt
+		// 0, 12: PMIC IRQ
+		{ PORT_0, PIN_13, GPIO_FUNC_IN, GPIO_PAD_NONE },        // BHI160 interrupt, not sure if PP
+		// 0, 14: PMIC I2C
+		// 0, 15: PMIC I2C
+		{ PORT_0, PIN_16, GPIO_FUNC_IN, GPIO_PAD_PULL_UP },     // PMIC AMUX
+		{ PORT_0, PIN_17, GPIO_FUNC_IN, GPIO_PAD_PULL_DOWN },   // SOA GPIO
+		// 0, 18: ECG AOUT
+		// 0, 19: 32 kHz
+		{ PORT_0, PIN_20, GPIO_FUNC_IN, GPIO_PAD_PULL_DOWN },   // Wristband 1
+		{ PORT_0, PIN_21, GPIO_FUNC_IN, GPIO_PAD_PULL_DOWN },   // Wristband 2
+		{ PORT_0, PIN_22, GPIO_FUNC_IN, GPIO_PAD_PULL_DOWN },   // Wristband 3
+		{ PORT_0, PIN_23, GPIO_FUNC_OUT, GPIO_PAD_NONE },       // IR-LED
+		{ PORT_0, PIN_24, GPIO_FUNC_OUT, GPIO_PAD_NONE },       // display SS
+		{ PORT_0, PIN_25, GPIO_FUNC_OUT, GPIO_PAD_NONE },       // display MOSI
+		{ PORT_0, PIN_26, GPIO_FUNC_IN, GPIO_PAD_PULL_DOWN },   // SOA GPIO
+		{ PORT_0, PIN_27, GPIO_FUNC_OUT, GPIO_PAD_NONE },       // display SCK
+		{ PORT_0, PIN_28, GPIO_FUNC_OUT, GPIO_PAD_NONE },       // Backlight
+		{ PORT_0, PIN_29, GPIO_FUNC_IN, GPIO_PAD_PULL_DOWN },   // Wristband 4
+		// 0, 30: PMIC power hold
+		{ PORT_0, PIN_31, GPIO_FUNC_OUT, GPIO_PAD_NONE },   // ECG switch
+
+		{ PORT_1, PIN_0, GPIO_FUNC_OUT, GPIO_PAD_NONE },    // SDHC
+		{ PORT_1, PIN_1, GPIO_FUNC_OUT, GPIO_PAD_NONE },    // SDHC
+		{ PORT_1, PIN_2, GPIO_FUNC_OUT, GPIO_PAD_NONE },    // SDHC
+		{ PORT_1, PIN_3, GPIO_FUNC_OUT, GPIO_PAD_NONE },    // SDHC
+		{ PORT_1, PIN_4, GPIO_FUNC_OUT, GPIO_PAD_NONE },    // SDHC
+		{ PORT_1, PIN_5, GPIO_FUNC_OUT, GPIO_PAD_NONE },    // SDHC
+		{ PORT_1, PIN_6, GPIO_FUNC_OUT, GPIO_PAD_NONE },    // display RS
+		{ PORT_1, PIN_7, GPIO_FUNC_IN, GPIO_PAD_PULL_UP },  // Portexpander interrupt
+		{ PORT_1, PIN_8, GPIO_FUNC_IN, GPIO_PAD_PULL_UP },  // ECG CS TODO: better OUT high
+		{ PORT_1, PIN_9, GPIO_FUNC_OUT, GPIO_PAD_NONE },    // ECG SDI
+		{ PORT_1, PIN_10, GPIO_FUNC_IN, GPIO_PAD_PULL_UP }, // ECG SDO
+		{ PORT_1, PIN_11, GPIO_FUNC_IN, GPIO_PAD_PULL_UP }, // ECG SCK
+		{ PORT_1, PIN_11, GPIO_FUNC_IN, GPIO_PAD_PULL_UP }, // ECG INT
+		{ PORT_1, PIN_13, GPIO_FUNC_IN, GPIO_PAD_NONE },    // PPG Interrupt
+		{ PORT_1, PIN_14, GPIO_FUNC_OUT, GPIO_PAD_NONE },   // RGB LEDs
+		{ PORT_1, PIN_15, GPIO_FUNC_OUT, GPIO_PAD_NONE },   // RGB LEDs
+	};
+	/* clang-format on */
+
+	const unsigned int num_pins =
+		(sizeof(pins_low_power) / sizeof(gpio_cfg_t));
+	for (size_t i = 0; i < num_pins; i++) {
+		GPIO_OutClr(&pins_low_power[i]);
+		GPIO_Config(&pins_low_power[i]);
+	}
+}
+
+/*
+ * Go to deepsleep, turning off peripherals.
+ *
+ * This functions returns after waking up again.
+ * Currently the only wakeup source is an interrupt
+ * from the PMIC.
+ *
+ * Some peripherals and GPIOs are moved into a low
+ * power state before going to sleep. There is no guarantee
+ * that all peripherals will be moved to a low power state
+ *
+ * TODO: Move BHI160, BMA400, BME680, MAX30001 into a low
+ * power state.
+ *
+ * The state of the GPIOs and generally all peripherials
+ * on board is not restored after a wakeup.
+ */
+void sleep_deepsleep(void)
+{
+	LOG_WARN("pmic", "Powersave");
+	epic_disp_backlight(0);
+	epic_leds_set_rocket(0, 0);
+	epic_leds_set_rocket(1, 0);
+	epic_leds_set_rocket(2, 0);
+#if 1
+	/* This will fail if there is no
+     * harmonic board attached */
+	max86150_begin();
+	max86150_get_int1();
+	max86150_get_int2();
+	max86150_shut_down();
+#endif
+	epic_bhi160_disable_all_sensors();
+	epic_bme680_deinit();
+	epic_max30001_disable_sensor();
+	MAX77650_setEN_SBB2(0b100);
+	MAX77650_setSBIA_LPM(true);
+	core1_stop();
+	MAX77650_getINT_GLBL();
+	gpio_low_power();
+	if (ble_is_enabled()) {
+		BbDrvDisable();
+	}
+	turnOffClocks();
+
+	SYS_ClockSourceEnable(SYS_CLOCK_HIRC);
+	old_clkcn = MXC_GCR->clkcn;
+	switchToHIRC();
+	deepsleep();
+
+	/* Now wait for an interrupt to wake us up */
+
+	turnOnClocks();
+	MXC_GCR->clkcn = old_clkcn;
+	while (!(MXC_GCR->clkcn & MXC_F_GCR_CLKCN_CKRDY))
+		; /* Wait for the clock switch to occur */
+	SystemCoreClockUpdate();
+	MAX77650_setEN_SBB2(0b110);
+}
+
+int epic_sleep(uint32_t ms)
+{
+	/* Allow the interrupt module to break us out of a call to
+	 * epic_sleep() */
+	uint32_t count = ulTaskNotifyTake(pdTRUE, pdMS_TO_TICKS(ms));
+
+	if (count == 0) {
+		return 0;
+	} else {
+		return INT_MAX;
+	}
+}

epicardium/modules/usb.c → epicardium/drivers/usb.c

@@ -11,18 +11,22 @@
 
 #include "epicardium.h"
 
-#include "modules/filesystem.h"
+#include "fs/filesystem.h"
+#include "os/config.h"
 
 #include "usb/cdcacm.h"
 #include "usb/mass_storage.h"
 #include "usb/descriptors.h"
 #include "usb/epc_usb.h"
 
-#include "modules/log.h"
+#include "os/core.h"
 
 #include "mx25lba.h"
 #include "msc.h"
 
+#include "mxc_sys.h"
+#include "wdt.h"
+
 /* memory access callbacks for the mass storage (FLASH) device */
 static int mscmem_init();
 static uint32_t mscmem_size(void);
@@ -95,6 +99,9 @@ static uint32_t mscmem_size(void)
 
 static int mscmem_read(uint32_t lba, uint8_t *buffer)
 {
+	/* Reset the watchdog as this interrupt might be
+	 * firing back to back for a few seconds. */
+	WDT_ResetTimer(MXC_WDT0);
 	return mx25_read(lba, buffer);
 }
 
@@ -104,6 +111,9 @@ static int mscmem_write(uint32_t lba, uint8_t *buffer)
 		//bootloader_dirty();
 	}
 	dirty = 2;
+	/* Reset the watchdog as this interrupt might be
+	 * firing back to back for a few seconds. */
+	WDT_ResetTimer(MXC_WDT0);
 	return mx25_write(lba, buffer);
 }
 
@@ -139,6 +149,7 @@ int epic_usb_shutdown(void)
 	esb_deinit();
 	if (s_fsDetached) {
 		fatfs_attach();
+		load_config();
 	}
 	return 0;
 }
@@ -155,6 +166,7 @@ int epic_usb_cdcacm(void)
 	esb_deinit();
 	if (s_fsDetached) {
 		fatfs_attach();
+		load_config();
 	}
 	return esb_init(&s_cfg_cdcacm);
 }
@@ -196,7 +208,7 @@ static struct config_descriptor_cdcacm config_descriptor_cdcacm = {
         .bNumEndpoints      = 0x01,
         .bInterfaceClass    = CLS_COMM,
         .bInterfaceSubClass = SCLS_ACM,
-        .bInterfaceProtocol = PROT_AT_CMDS,
+        .bInterfaceProtocol = 0x00,
         .iInterface         = 0x00,
     },
     .header_functional = {

epicardium/drivers/vibra.c

+#include "gpio.h"
+#include "FreeRTOS.h"
+#include "timers.h"
+
+static const gpio_cfg_t motor_pin = {
+	PORT_0, PIN_8, GPIO_FUNC_OUT, GPIO_PAD_NONE
+};
+
+static StaticTimer_t vibra_timer_data;
+static TimerHandle_t vibra_timer = NULL;
+
+void epic_vibra_set(int status)
+{
+	if (status) {
+		GPIO_OutSet(&motor_pin);
+	} else {
+		GPIO_OutClr(&motor_pin);
+	}
+}
+
+void vTimerCallback()
+{
+	epic_vibra_set(0);
+}
+
+void epic_vibra_vibrate(int millis)
+{
+	int ticks = millis * (configTICK_RATE_HZ / 1000);
+
+	if (vibra_timer == NULL) {
+		vibra_timer = xTimerCreateStatic(
+			"vibratimer",
+			1,
+			pdFALSE, /* one-shot */
+			0,
+			vTimerCallback,
+			&vibra_timer_data);
+	}
+
+	/* Make sure the duration is valid */
+	if (ticks < 1) {
+		/* Disable a potentially running motor / timer */
+		epic_vibra_set(0);
+		xTimerStop(vibra_timer, 0);
+		return;
+	}
+
+	if (vibra_timer != NULL) {
+		epic_vibra_set(1);
+		xTimerChangePeriod(vibra_timer, ticks, 0);
+	}
+}

epicardium/modules/watchdog.c → epicardium/drivers/watchdog.c

-#include "modules/log.h"
+#include "os/core.h"
 #include "modules/modules.h"
 
 #include "timers.h"

epicardium/drivers/ws2812.c

+#include "leds.h"
+#include "pmic.h"
+#include "FreeRTOS.h"
+#include "task.h"
+#include "epicardium.h"
+#include "max32665.h"
+#include "gpio.h"
+#include "modules/modules.h"
+#include "drivers/drivers.h"
+
+#include <stdbool.h>
+
+#define OVERHEAD 33
+
+#define EPIC_WS2812_ZERO_HIGH_TICKS (34 - OVERHEAD)
+#define EPIC_WS2812_ZERO_LOW_TICKS (86 - OVERHEAD)
+#define EPIC_WS2812_ONE_HIGH_TICKS (86 - OVERHEAD)
+#define EPIC_WS2812_ONE_LOW_TICKS (34 - OVERHEAD)
+#define EPIC_WS2812_RESET_TCKS (4800 - OVERHEAD)
+
+static volatile uint32_t counter = 0;
+
+static inline __attribute__((always_inline)) void
+epic_ws2812_delay_ticks(uint32_t ticks)
+{
+	counter = ticks;
+	while (--counter) {
+	};
+}
+
+static inline __attribute__((always_inline)) void
+epic_ws2812_transmit_bit(gpio_cfg_t *pin, uint8_t bit)
+{
+	if (bit != 0) {
+		GPIO_OutSet(pin);
+		epic_ws2812_delay_ticks(EPIC_WS2812_ONE_HIGH_TICKS);
+		GPIO_OutClr(pin);
+		epic_ws2812_delay_ticks(EPIC_WS2812_ONE_LOW_TICKS);
+	} else {
+		GPIO_OutSet(pin);
+		epic_ws2812_delay_ticks(EPIC_WS2812_ZERO_HIGH_TICKS);
+		GPIO_OutClr(pin);
+		epic_ws2812_delay_ticks(EPIC_WS2812_ZERO_LOW_TICKS);
+	}
+}
+
+static inline __attribute__((always_inline)) void
+epic_ws2812_transmit_byte(gpio_cfg_t *pin, uint8_t byte)
+{
+	epic_ws2812_transmit_bit(pin, byte & 0b10000000);
+	epic_ws2812_transmit_bit(pin, byte & 0b01000000);
+	epic_ws2812_transmit_bit(pin, byte & 0b00100000);
+	epic_ws2812_transmit_bit(pin, byte & 0b00010000);
+	epic_ws2812_transmit_bit(pin, byte & 0b00001000);
+	epic_ws2812_transmit_bit(pin, byte & 0b00000100);
+	epic_ws2812_transmit_bit(pin, byte & 0b00000010);
+	epic_ws2812_transmit_bit(pin, byte & 0b00000001);
+}
+
+void epic_ws2812_write(uint8_t pin, uint8_t *pixels, uint32_t n_bytes)
+{
+	uint8_t *pixels_end = pixels + n_bytes;
+	gpio_cfg_t *pin_cfg = &gpio_configs[pin];
+
+	taskENTER_CRITICAL();
+
+	/*
+	 * If the pin was not previously configured as an output, the
+	 * `epic_gpio_set_pin_mode()` call will pull it down which the first
+	 * neopixel interprets as the color `0x008000`.  To fix this, wait a bit
+	 * after mode-setting and then write the new values.
+	 */
+	if ((epic_gpio_get_pin_mode(pin) & EPIC_GPIO_MODE_OUT) == 0) {
+		epic_gpio_set_pin_mode(pin, EPIC_GPIO_MODE_OUT);
+	}
+
+	GPIO_OutClr(pin_cfg);
+	epic_ws2812_delay_ticks(EPIC_WS2812_RESET_TCKS);
+
+	do {
+		epic_ws2812_transmit_byte(pin_cfg, *pixels);
+	} while (++pixels != pixels_end);
+
+	taskEXIT_CRITICAL();
+}

epicardium/epic_boot.c

+#include <math.h>
+
+static const uint8_t pride_colors[6][3] = {
+	{ 0xe4, 0x02, 0x02 }, { 0xff, 0x8c, 0x00 }, { 0xff, 0xed, 0x00 },
+	{ 0x00, 0x80, 0x26 }, { 0x00, 0x4d, 0xff }, { 0x75, 0x06, 0x87 },
+};
+
+static void epic_frame(Ctx *epicardium_ctx, float frame)
+{
+	int num_colors = sizeof(pride_colors) / sizeof(pride_colors[0]);
+	for (int color = 0; color < num_colors; color++) {
+		ctx_rgba8_stroke(
+			epicardium_ctx,
+			pride_colors[color][0],
+			pride_colors[color][1],
+			pride_colors[color][2],
+			0xff
+		);
+		ctx_line_width(epicardium_ctx, 10.0);
+		ctx_line_cap(epicardium_ctx, CTX_CAP_ROUND);
+
+		float width =
+			expf(-pow(frame / 2.0 - 5 + color / 2.0, 2)) * 55.0 +
+			5.0;
+
+		float ypos = color * 10.0 + 40.0 - (num_colors - 1) * 5.0;
+
+		ctx_move_to(epicardium_ctx, 80.0 - width, ypos);
+		ctx_line_to(epicardium_ctx, 80.0 + width, ypos);
+		ctx_stroke(epicardium_ctx);
+	}
+
+	ctx_save(epicardium_ctx);
+
+	ctx_font_size(epicardium_ctx, 20.0f);
+	ctx_text_baseline(epicardium_ctx, CTX_TEXT_BASELINE_BOTTOM);
+	ctx_rgba8(epicardium_ctx, 0xff, 0xff, 0xff, 0xff);
+
+	ctx_text_align(epicardium_ctx, CTX_TEXT_ALIGN_CENTER);
+	ctx_move_to(epicardium_ctx, 80.0f, 58.0f);
+	ctx_text(epicardium_ctx, "Epicardium");
+
+	if (strcmp(CARD10_VERSION, "v1.18") != 0) {
+		ctx_text_align(epicardium_ctx, CTX_TEXT_ALIGN_LEFT);
+		ctx_move_to(epicardium_ctx, 2.0f, 78.0f);
+		ctx_text(epicardium_ctx, CARD10_VERSION);
+	} else {
+		ctx_move_to(epicardium_ctx, 80.0f, 78.0f);
+		ctx_text(epicardium_ctx, "Queer Quinoa");
+	}
+
+	ctx_restore(epicardium_ctx);
+}

epicardium/epicardium.h

@@ -33,9 +33,11 @@ typedef _Bool bool;
 #define API_SYSTEM_EXEC             0x2
 #define API_SYSTEM_RESET            0x3
 #define API_BATTERY_VOLTAGE         0x4
+#define API_SLEEP                   0x5
 
 #define API_INTERRUPT_ENABLE        0xA
 #define API_INTERRUPT_DISABLE       0xB
+#define API_INTERRUPT_IS_ENABLED    0xC
 
 #define API_UART_WRITE_STR         0x10
 #define API_UART_READ_CHAR         0x11
@@ -54,6 +56,8 @@ typedef _Bool bool;
 #define API_DISP_PIXEL             0x28
 #define API_DISP_FRAMEBUFFER       0x29
 #define API_DISP_BACKLIGHT         0x2a
+#define API_DISP_PRINT_ADV         0x2b
+#define API_DISP_BLIT              0x2d
 
 /* API_BATTERY_VOLTAGE              0x30 */
 #define API_BATTERY_CURRENT        0x31
@@ -75,11 +79,14 @@ typedef _Bool bool;
 #define API_FILE_UNLINK            0x4b
 #define API_FILE_RENAME            0x4c
 #define API_FILE_MKDIR             0x4d
+#define API_FILE_FS_ATTACHED       0x4e
 
 #define API_RTC_GET_SECONDS        0x50
 #define API_RTC_SCHEDULE_ALARM     0x51
 #define API_RTC_SET_MILLISECONDS   0x52
 #define API_RTC_GET_MILLISECONDS   0x53
+#define API_RTC_GET_MONOTONIC_SECONDS      0x54
+#define API_RTC_GET_MONOTONIC_MILLISECONDS 0x55
 
 #define API_LEDS_SET               0x60
 #define API_LEDS_SET_HSV           0x61
@@ -95,6 +102,9 @@ typedef _Bool bool;
 #define API_LEDS_SET_ALL_HSV       0x6b
 #define API_LEDS_SET_GAMMA_TABLE   0x6c
 #define API_LEDS_CLEAR_ALL         0x6d
+#define API_LEDS_GET_ROCKET        0x6e
+#define API_LEDS_GET               0x6f
+#define API_LEDS_FLASH_ROCKET      0x72
 
 #define API_VIBRA_SET              0x70
 #define API_VIBRA_VIBRATE          0x71
@@ -102,6 +112,7 @@ typedef _Bool bool;
 #define API_LIGHT_SENSOR_RUN       0x80
 #define API_LIGHT_SENSOR_GET       0x81
 #define API_LIGHT_SENSOR_STOP      0x82
+#define API_LIGHT_SENSOR_READ	   0x83
 
 #define API_BUTTONS_READ           0x90
 
@@ -111,6 +122,7 @@ typedef _Bool bool;
 #define API_GPIO_READ_PIN          0xA3
 
 #define API_TRNG_READ              0xB0
+#define API_CSPRNG_READ            0XB1
 
 #define API_PERSONAL_STATE_SET     0xc0
 #define API_PERSONAL_STATE_GET     0xc1
@@ -119,6 +131,7 @@ typedef _Bool bool;
 #define API_BME680_INIT            0xD0
 #define API_BME680_DEINIT          0xD1
 #define API_BME680_GET_DATA        0xD2
+#define API_BSEC_GET_DATA          0xD3
 
 #define API_BHI160_ENABLE          0xe0
 #define API_BHI160_DISABLE         0xe1
@@ -127,14 +140,60 @@ typedef _Bool bool;
 #define API_MAX30001_ENABLE        0xf0
 #define API_MAX30001_DISABLE       0xf1
 
-#define API_MAX86150_INIT		0x0100
-#define API_MAX86150_GET_DATA		0x0101
-#define API_MAX86150_SET_LED_AMPLITUDE	0x0102
+#define API_MAX86150_ENABLE        0x0100
+#define API_MAX86150_DISABLE       0x0101
 
 #define API_USB_SHUTDOWN           0x110
 #define API_USB_STORAGE            0x111
 #define API_USB_CDCACM             0x112
 
+#define API_WS2812_WRITE           0x0120
+
+#define API_CONFIG_GET_STRING      0x130
+#define API_CONFIG_GET_INTEGER     0x131
+#define API_CONFIG_GET_BOOLEAN     0x132
+#define API_CONFIG_SET_STRING      0x133
+
+#define API_BLE_GET_COMPARE_VALUE     0x140
+#define API_BLE_COMPARE_RESPONSE      0x141
+#define API_BLE_SET_MODE              0x142
+#define API_BLE_GET_EVENT             0x143
+#define API_BLE_GET_SCAN_REPORT       0x144
+#define API_BLE_GET_LAST_PAIRING_NAME 0x145
+#define API_BLE_GET_PEER_DEVICE_NAME  0x146
+#define API_BLE_FREE_EVENT            0x147
+
+#define API_BLE_HID_SEND_REPORT        0x150
+
+#define API_BLE_ATTS_DYN_CREATE_GROUP         0x160
+#define API_BLE_ATTS_DYN_DELETE_GROUP         0x161
+#define API_BLE_ATTS_DYN_DELETE_GROUPS        0x169
+#define API_BLE_ATTS_DYN_ADD_CHARACTERISTIC   0x16B
+#define API_BLE_ATTS_DYN_ADD_DESCRIPTOR       0x163
+#define API_BLE_ATTS_SET_BUFFER               0x16A
+#define API_BLE_ATTS_SEND_SERVICE_CHANGED_IND 0x168
+
+#define API_BLE_ATTS_SET_ATTR                 0x170
+#define API_BLE_ATTS_HANDLE_VALUE_NTF         0x171
+#define API_BLE_ATTS_HANDLE_VALUE_IND         0x172
+
+#define API_BLE_CLOSE_CONNECTION              0x180
+#define API_BLE_IS_CONNECTION_OPEN            0x181
+#define API_BLE_SET_DEVICE_NAME               0x182
+#define API_BLE_GET_DEVICE_NAME               0x183
+#define API_BLE_GET_ADDRESS                   0x184
+#define API_BLE_ADVERTISE                     0x185
+#define API_BLE_ADVERTISE_STOP                0x186
+#define API_BLE_DISCOVER_PRIMARY_SERVICES     0x187
+#define API_BLE_DISCOVER_CHARACTERISTICS      0x188
+#define API_BLE_DISCOVER_DESCRIPTORS          0x189
+#define API_BLE_ATTC_READ                     0x18A
+#define API_BLE_ATTC_WRITE_NO_RSP             0x18B
+#define API_BLE_ATTC_WRITE                    0x18C
+
+#define API_BLE_INIT                          0x190
+#define API_BLE_DEINIT                        0x191
+
 /* clang-format on */
 
 typedef uint32_t api_int_id_t;
@@ -146,6 +205,17 @@ typedef uint32_t api_int_id_t;
  * the other direction.  These interrupts can be enabled/disabled
  * (masked/unmasked) using :c:func:`epic_interrupt_enable` and
  * :c:func:`epic_interrupt_disable`.
+ *
+ * These interrupts work similar to hardware interrupts:  You will only get a
+ * single interrupt, even if multiple events occured since the ISR last ran
+ * (*this behavior is new since version 1.16*).
+ *
+ * .. warning::
+ *
+ *    Never attempt to call the API from inside an ISR.  This might trigger an
+ *    assertion if a call is already being made from thread context.  We plan to
+ *    lift this restriction at some point, but for the time being, this is how
+ *    it is.
  */
 
 /**
@@ -162,6 +232,19 @@ API(API_INTERRUPT_ENABLE, int epic_interrupt_enable(api_int_id_t int_id));
  */
 API(API_INTERRUPT_DISABLE, int epic_interrupt_disable(api_int_id_t int_id));
 
+/**
+ * Check if an API interrupt is enabled.
+ *
+ * :param int int_id: The interrupt to be checked
+ * :param bool* enabled: ``true`` will be stored here if the interrupt is enabled.
+ *   ``false`` otherwise.
+ *
+ * :return: 0 on success, ``-EINVAL`` if the interrupt is unknown.
+ *
+ * .. versionadded:: 1.16
+ */
+API(API_INTERRUPT_IS_ENABLED, int epic_interrupt_is_enabled(api_int_id_t int_id, bool *enabled));
+
 /**
  * The following interrupts are defined:
  */
@@ -173,20 +256,25 @@ API(API_INTERRUPT_DISABLE, int epic_interrupt_disable(api_int_id_t int_id));
 #define EPIC_INT_CTRL_C                 1
 /** UART Receive interrupt.  See :c:func:`epic_isr_uart_rx`. */
 #define EPIC_INT_UART_RX                2
-/** RTC Alarm interrupt.  See :c:func:`epic_isr_rtc_alarm` */
+/** RTC Alarm interrupt.  See :c:func:`epic_isr_rtc_alarm`. */
 #define EPIC_INT_RTC_ALARM              3
-/** BHI */
+/** BHI160 Accelerometer.  See :c:func:`epic_isr_bhi160_accelerometer`. */
 #define EPIC_INT_BHI160_ACCELEROMETER	4
-API_ISR(EPIC_INT_BHI160_ACCELEROMETER, epic_isr_bhi160_accelerometer);
+/** BHI160 Orientation Sensor.  See :c:func:`epic_isr_bhi160_orientation`. */
 #define EPIC_INT_BHI160_ORIENTATION	5
-API_ISR(EPIC_INT_BHI160_ORIENTATION, epic_isr_bhi160_orientation);
+/** BHI160 Gyroscope.  See :c:func:`epic_isr_bhi160_gyroscope`. */
 #define EPIC_INT_BHI160_GYROSCOPE	6
-API_ISR(EPIC_INT_BHI160_GYROSCOPE, epic_isr_bhi160_gyroscope);
+/** MAX30001 ECG.  See :c:func:`epic_isr_max30001_ecg`. */
 #define EPIC_INT_MAX30001_ECG		7
-API_ISR(EPIC_INT_MAX30001_ECG, epic_isr_max30001_ecg);
-
+/** BHI160 Magnetometer.  See :c:func:`epic_isr_bhi160_magnetometer`. */
+#define EPIC_INT_BHI160_MAGNETOMETER    8
+/** MAX86150 ECG and PPG sensor.  See :c:func:`epic_isr_max86150`. */
+#define EPIC_INT_MAX86150               9
+/** Bluetooth Low Energy event.  See :c:func:`epic_isr_ble`. */
+#define EPIC_INT_BLE                    10
+#define EPIC_INT_MAX86150_PROX          11
 /* Number of defined interrupts. */
-#define EPIC_INT_NUM                    8
+#define EPIC_INT_NUM                    12
 /* clang-format on */
 
 /*
@@ -248,6 +336,25 @@ API(API_SYSTEM_EXEC, int __epic_exec(char *name));
  */
 API(API_SYSTEM_RESET, void epic_system_reset(void));
 
+/**
+ * Sleep for the specified amount of time.
+ *
+ * This call will block for at most the specified amount of time. It allows epicardium to
+ * reduce clock speed of the system until this call is finished.
+ *
+ * This call returns early if an interrupt is signaled from epicardium.
+ *
+ * The clock source of epicardium has a limited amount of accuracy. Tolerances
+ * of +- 10% have been observed. This means that the sleep time also has a
+ * tolarance of at least +- 10%. The exact amount varies from device to device and
+ * also with temperature. You should take this into consideration when selecting
+ * the time you want to sleep.
+ *
+ * :param ms:  Time to wait in milliseconds
+ * :returns: 0 if no interrupt happened, ``INT_MAX`` if an interrupt happened and the sleep ended early.
+ */
+API(API_SLEEP, int epic_sleep(uint32_t ms));
+
 /**
  * PMIC API
  * ===============
@@ -301,8 +408,7 @@ API(API_THERMISTOR_VOLTAGE, int epic_read_thermistor_voltage(float *result));
  * :param length:  Amount of bytes to print.
  */
 API(API_UART_WRITE_STR, void epic_uart_write_str(
-	const char *str,
-	intptr_t length
+	const char *str, size_t length
 ));
 
 /**
@@ -328,7 +434,7 @@ API(API_UART_READ_CHAR, int epic_uart_read_char(void));
 API(API_UART_READ_STR, int epic_uart_read_str(char *buf, size_t cnt));
 
 /**
- * **Interrupt Service Routine**
+ * **Interrupt Service Routine** for :c:data:`EPIC_INT_UART_RX`
  *
  * UART receive interrupt.  This interrupt is triggered whenever a new character
  * becomes available on any connected UART device.  This function is weakly
@@ -358,7 +464,7 @@ API(API_UART_READ_STR, int epic_uart_read_str(char *buf, size_t cnt));
 API_ISR(EPIC_INT_UART_RX, epic_isr_uart_rx);
 
 /**
- * **Interrupt Service Routine**
+ * **Interrupt Service Routine** for :c:data:`EPIC_INT_CTRL_C`
  *
  * A user-defineable ISR which is triggered when a ``^C`` (``0x04``) is received
  * on any serial input device.  This function is weakly aliased to
@@ -457,6 +563,7 @@ enum gpio_mode {
     EPIC_GPIO_MODE_IN = (1<<0),
     /** Configure the pin as output */
     EPIC_GPIO_MODE_OUT = (1<<1),
+    EPIC_GPIO_MODE_ADC = (1<<2),
 
     /** Enable the internal pull-up resistor */
     EPIC_GPIO_PULL_UP = (1<<6),
@@ -485,7 +592,9 @@ enum gpio_mode {
  * :param uint8_t mode: Mode to be configured. Use a combination of the :c:type:`gpio_mode` flags.
  * :returns: ``0`` if the mode was set, ``-EINVAL`` if ``pin`` is not valid or the mode could not be set.
  */
-API(API_GPIO_SET_PIN_MODE, int epic_gpio_set_pin_mode(uint8_t pin, uint8_t mode));
+API(API_GPIO_SET_PIN_MODE, int epic_gpio_set_pin_mode(
+	uint8_t pin, uint8_t mode
+));
 
 /**
  * Get the mode of a card10 GPIO pin.
@@ -580,6 +689,34 @@ API(API_GPIO_READ_PIN, int epic_gpio_read_pin(uint8_t pin));
  */
 API(API_LEDS_SET, void epic_leds_set(int led, uint8_t r, uint8_t g, uint8_t b));
 
+
+/**
+ * Get one of card10's RGB LEDs in format of RGB.
+ *
+ * :c:func:`epic_leds_get_rgb` will get the value of a RGB  LED described by ``led``.
+ *
+ * :param int led:  Which LED to get.  0-10 are the LEDs on the top and 11-14
+ *    are the 4 "ambient" LEDs.
+ * :param uint8_t * rgb:  need tree byte array to get the value of red, green and blue.
+ * :returns: ``0`` on success or ``-EPERM`` if the LED is blocked by personal-state.
+ *
+ * .. versionadded:: 1.10
+ */
+API(API_LEDS_GET, int epic_leds_get_rgb(int led, uint8_t * rgb));
+
+/**
+ * Set one of the rockets to flash for a certain time.
+ *
+ * :c:func:`epic_leds_flash_rocket` will set a timer for the flash of a rocket.
+ *
+ * :param int led: Number of the rocket that sould flash 
+ * :param uint8_t value:  brightness of the 'on'-state of this rocket ( 0 < value < 32)
+ * :param int millis:  time in milliseconds defining the duration of the flash (i.e. how long is the rocket 'on')
+ *
+ * .. versionadded:: 1.16
+ */
+API(API_LEDS_FLASH_ROCKET, void epic_leds_flash_rocket(int led, uint8_t valiue, int millis));
+
 /**
  * Set one of card10's RGB LEDs to a certain color in HSV format.
  *
@@ -592,7 +729,9 @@ API(API_LEDS_SET, void epic_leds_set(int led, uint8_t r, uint8_t g, uint8_t b));
  * :param float s:  Saturation component of the color. (0 <= s <= 1)
  * :param float v:  Value/Brightness component of the color. (0 <= v <= 0)
  */
-API(API_LEDS_SET_HSV, void epic_leds_set_hsv(int led, float h, float s, float v));
+API(API_LEDS_SET_HSV, void epic_leds_set_hsv(
+	int led, float h, float s, float v
+));
 
 /**
  * Set multiple of card10's RGB LEDs to a certain color in RGB format.
@@ -615,7 +754,9 @@ API(API_LEDS_SET_ALL, void epic_leds_set_all(uint8_t *pattern, uint8_t len));
  *    LEDs. (0 <= h < 360, 0 <= s <= 1, 0 <= v <= 1)
  * :param uint8_t len: Length of 1st dimension of ``pattern``, see above.
  */
-API(API_LEDS_SET_ALL_HSV, void epic_leds_set_all_hsv(float *pattern, uint8_t len));
+API(API_LEDS_SET_ALL_HSV, void epic_leds_set_all_hsv(
+	float *pattern, uint8_t len
+));
 
 /**
  * Prepare one of card10's RGB LEDs to be set to a certain color in RGB format.
@@ -628,7 +769,9 @@ API(API_LEDS_SET_ALL_HSV, void epic_leds_set_all_hsv(float *pattern, uint8_t len
  * :param uint8_t g:  Green component of the color.
  * :param uint8_t b:  Blue component of the color.
  */
-API(API_LEDS_PREP, void epic_leds_prep(int led, uint8_t r, uint8_t g, uint8_t b));
+API(API_LEDS_PREP, void epic_leds_prep(
+	int led, uint8_t r, uint8_t g, uint8_t b
+));
 
 /**
  * Prepare one of card10's RGB LEDs to be set to a certain color in HSV format.
@@ -641,7 +784,9 @@ API(API_LEDS_PREP, void epic_leds_prep(int led, uint8_t r, uint8_t g, uint8_t b)
  * :param uint8_t s:  Saturation component of the color. (float, 0 <= s <= 1)
  * :param uint8_t v:  Value/Brightness component of the color. (float, 0 <= v <= 0)
  */
-API(API_LEDS_PREP_HSV, void epic_leds_prep_hsv(int led, float h, float s, float v));
+API(API_LEDS_PREP_HSV, void epic_leds_prep_hsv(
+	int led, float h, float s, float v
+));
 
 /**
  * Set global brightness for top RGB LEDs.
@@ -705,6 +850,26 @@ API(API_LEDS_UPDATE, void epic_leds_update(void));
  */
 API(API_LEDS_SET_ROCKET, void epic_leds_set_rocket(int led, uint8_t value));
 
+/**
+ * Get the brightness of one of the rocket LEDs.
+ *
+ * :param int led:  Which LED to get.
+ *
+ *    +-------+--------+----------+
+ *    |   ID  | Color  | Location |
+ *    +=======+========+==========+
+ *    | ``0`` | Blue   | Left     |
+ *    +-------+--------+----------+
+ *    | ``1`` | Yellow | Top      |
+ *    +-------+--------+----------+
+ *    | ``2`` | Green  | Right    |
+ *    +-------+--------+----------+
+ * :returns value:  Brightness of LED (value between 0 and 31)  or ``-EINVAL`` if the LED/rocket does not exists.
+ *
+ * .. versionadded:: 1.10
+ */
+API(API_LEDS_GET_ROCKET, int epic_leds_get_rocket(int led));
+
 /**
  * Turn on the bright side LED which can serve as a flashlight if worn on the left wrist or as a rad tattoo illuminator if worn on the right wrist.
  *
@@ -724,8 +889,7 @@ API(API_LEDS_SET_FLASHLIGHT, void epic_set_flashlight(bool power));
  * :param uint8_t[256] gamma_table: Gamma lookup table. (default = 4th order power function rounded up)
  */
 API(API_LEDS_SET_GAMMA_TABLE, void epic_leds_set_gamma_table(
-	uint8_t rgb_channel,
-	uint8_t *gamma_table
+	uint8_t rgb_channel, uint8_t *gamma_table
 ));
 
 /**
@@ -735,7 +899,9 @@ API(API_LEDS_SET_GAMMA_TABLE, void epic_leds_set_gamma_table(
  * :param uint8_t g: Value for the green color channel.
  * :param uint8_t b: Value for the blue color channel.
  */
-API(API_LEDS_CLEAR_ALL, void epic_leds_clear_all(uint8_t r, uint8_t g, uint8_t b));
+API(API_LEDS_CLEAR_ALL, void epic_leds_clear_all(
+	uint8_t r, uint8_t g, uint8_t b
+));
 
 /**
  * BME680
@@ -802,8 +968,225 @@ API(API_BME680_DEINIT, int epic_bme680_deinit());
  *     - ``-EIO``:  Communication with the device failed.
  *     - ``-ENODEV``:  Device was not found.
  */
-API(API_BME680_GET_DATA,
-	int epic_bme680_read_sensors(struct bme680_sensor_data *data));
+API(API_BME680_GET_DATA, int epic_bme680_read_sensors(
+	struct bme680_sensor_data *data
+));
+
+/**
+ * .. _bsec_api:
+ *
+ * BSEC
+ * ----
+ * The Bosch Sensortec Environmental Cluster (BSEC) library
+ * allows to estimate an indoor air qualtiy (IAQ) metric as
+ * well as CO2 and VOC content equivalents using the gas sensor
+ * of the BME680.
+ *
+ * As it is a proprietary binary blob, it has to be enabled using
+ * the ``bsec_enable`` configuration option (see :ref:`card10_cfg`).
+ *
+ * Please also have a look at the BME680 datasheet and some of
+ * the BSEC documentation:
+ *
+ * https://git.card10.badge.events.ccc.de/card10/hardware/-/blob/master/datasheets/bosch/BST-BME680-DS001.pdf
+ *
+ * https://git.card10.badge.events.ccc.de/card10/firmware/-/blob/master/lib/vendor/Bosch/BSEC/integration_guide/BST-BME680-Integration-Guide-AN008-48.pdf
+ */
+
+/**
+ * BSEC Sensor Data
+ */
+struct bsec_sensor_data {
+	/** Compensated temperature in degree celsius */
+	float temperature;
+	/** Compensated humidity in % relative humidity */
+	float humidity;
+	/** Pressure in hPa */
+	float pressure;
+	/** Gas resistance in Ohms */
+	float gas_resistance;
+	/** Timestamp in of the measurement in UNIX time (seconds since
+	 * 1970-01-01 00:00:00 UTC)*/
+	uint32_t timestamp;
+	/** Accuracy of IAQ, CO2 equivalent and breath VOC equivalent:
+	 *
+	 * 0: Stabilization / run-in ongoing:
+	 *    This means that the sensor still needs to warm up. Takes about
+	 *    5 min after activation of BSEC / reboot.
+	 *
+	 * 1: Low accuracy:
+	 *    The sensor has not yet been calibrated. BSEC needs to collect
+	 *    more data to calibrate the sensor. This can take multiple
+	 *    hours.
+	 *
+	 *    BSEC documentation: To reach high accuracy(3) please expose
+	 *    sensor once to good air (e.g. outdoor air) and bad air (e.g.
+	 *    box with exhaled breath) for auto-trimming
+	 *
+	 * 2: Medium accuracy: auto-trimming ongoing
+	 *    BSEC has detected that it needs to recalibrate the sensor.
+	 *    This is an automatic process and usally finishes after tens
+	 *    of minutes. Can happen every now and then.
+	 *
+	 * 3: High accuracy:
+	 *    The sensor has warmed up and is calibrated.
+	 *
+	 * From BSEC documentation:
+	 * IAQ accuracy indicator will notify the user when they should
+	 * initiate a calibration process. Calibration is performed automatically
+	 * in the background if the sensor is exposed to clean and polluted air
+	 * for approximately 30 minutes each.
+	 *
+	 * See also:
+	 * https://community.bosch-sensortec.com/t5/MEMS-sensors-forum/BME680-IAQ-accuracy-definition/m-p/5931/highlight/true#M10
+	 */
+	uint8_t accuracy;
+	/** Indoor Air Quality with range 0 to 500
+	 *
+	 * Statement from the Bosch BSEC library:
+	 *
+	 * Indoor-air-quality (IAQ) gives an indication of the relative change
+	 * in ambient TVOCs detected by BME680.
+	 *
+	 * The IAQ scale ranges from 0 (clean air) to 500 (heavily polluted air).
+	 * During operation, algorithms automatically calibrate and adapt
+	 * themselves to the typical environments where the sensor is operated
+	 * (e.g., home, workplace, inside a car, etc.).This automatic background
+	 * calibration ensures that users experience consistent IAQ performance.
+	 * The calibration process considers the recent measurement history (typ.
+	 * up to four days) to ensure that IAQ=25 corresponds to typical good air
+	 * and IAQ=250 indicates typical polluted air.
+	 *
+	 * Please also consult the BME680 datsheet (pages 9 and 21) as well:
+	 * https://git.card10.badge.events.ccc.de/card10/hardware/-/blob/master/datasheets/bosch/BST-BME680-DS001.pdf
+	 *
+	 */
+	int32_t indoor_air_quality;
+	/** Unscaled IAQ value.
+	 *
+	 * See this post for details:
+	 * https://community.bosch-sensortec.com/t5/MEMS-sensors-forum/BME680-strange-IAQ-and-CO2-values/m-p/9667/highlight/true#M1505
+	 */
+	int32_t static_indoor_air_quality;
+	/** Estimation of equivalant CO2 content in the air in ppm. */
+	float co2_equivalent;
+	/** Estimation of equivalant breath VOC content in the air in ppm. */
+	float breath_voc_equivalent;
+};
+
+/**
+ *
+ * Get the current BME680 data filtered by Bosch BSEC library
+ *
+ * As it is a proprietary binary blob, it has to be enabled using
+ * the ``bsec_enable`` configuration option (see :ref:`card10_cfg`).
+ *
+ * The sample rate is currently fixed to one sample every 3 seconds.
+ * Querying the sensor more often will return cached data.
+ *
+ * After the libary has been activated it starts to calibrate the
+ * sensor. This can take multiple hours.
+ * After a reset/power on it takes about 5 minutes to stabilize
+ * the sensor if it was calibrated before.
+ *
+ * The BSEC library regularly recalibrates the sensor during operation.
+ * The ``accuracy`` field of the return data indicates the calibration
+ * status of the sensor. Please take it into consideration when
+ * using / displaying the IAQ.
+ *
+ * Please refer to the description of :c:type:`bsec_sensor_data` for more
+ * information about how to interpret its content.
+ *
+ * .. versionadded:: 1.x
+ *
+ * :param data: Where to store the environmental data.
+ * :return: 0 on success or ``-Exxx`` on error.  The following
+ *     errors might occur:
+ *
+ *     - ``-EFAULT``:  On NULL-pointer.
+ *     - ``-EINVAL``:  No data available from the sensor.
+ *     - ``-ENODEV``:  BSEC libray is not running.
+ */
+API(API_BSEC_GET_DATA, int epic_bsec_read_sensors(
+	struct bsec_sensor_data *data
+));
+/**
+ * MAX86150
+ * ========
+ */
+
+/**
+ * Configuration for a MAX86150 sensor.
+ *
+ * This struct is used when enabling a sensor using
+ * :c:func:`epic_max86150_enable_sensor`.
+ */
+struct max86150_sensor_config {
+    /**
+     * Number of samples Epicardium should keep for this sensor.  Do not set
+     * this number too high as the sample buffer will eat RAM.
+     */
+    size_t sample_buffer_len;
+    /**
+     * Sample rate for PPG from the sensor in Hz.  Maximum data rate is limited
+     * to 200 Hz for all sensors though some might be limited at a lower
+     * rate.
+     *
+     * Possible values are 10, 20, 50, 84, 100, 200.
+     */
+    uint16_t ppg_sample_rate;
+};
+
+/**
+ * MAX86150 Sensor Data
+ */
+struct max86150_sensor_data {
+	/** Red LED data */
+	uint32_t red;
+	/** IR LED data */
+	uint32_t ir;
+	/** ECG data */
+	int32_t ecg;
+};
+
+/**
+ * Enable a MAX86150 PPG and ECG sensor.
+ *
+ * Calling this function will instruct the MAX86150 to collect a
+ * data from the sensor.  You can then retrieve the samples using
+ * :c:func:`epic_stream_read`.
+ *
+ * :param max86150_sensor_config* config: Configuration for this sensor.
+ * :param size_t config_size: Size of ``config``.
+ * :returns: A sensor descriptor which can be used with
+ *    :c:func:`epic_stream_read` or a negative error value:
+ *
+ *    - ``-ENOMEM``:  The MAX86150 driver failed to create a stream queue.
+ *    - ``-ENODEV``:  The MAX86150 driver failed due to physical connectivity problem
+ *      (broken wire, unpowered, etc).
+ *    - ``-EINVAL``:  config->ppg_sample_rate is not one of 10, 20, 50, 84, 100, 200
+ *      or config_size is not size of config.
+ *
+ * .. versionadded:: 1.16
+ */
+API(API_MAX86150_ENABLE, int epic_max86150_enable_sensor(struct max86150_sensor_config *config, size_t config_size));
+
+/**
+ * Disable the MAX86150 sensor.
+ *
+ * :returns: 0 in case of success or forward negative error value from stream_deregister.
+ *
+ * .. versionadded:: 1.16
+ */
+API(API_MAX86150_DISABLE, int epic_max86150_disable_sensor());
+
+/**
+ * **Interrupt Service Routine** for :c:data:`EPIC_INT_MAX86150`
+ *
+ * :c:func:`epic_isr_max86150` is called whenever the MAX86150
+ * PPG sensor has new data available.
+ */
+API_ISR(EPIC_INT_MAX86150, epic_isr_max86150);
 
 /**
  * Personal State
@@ -846,8 +1229,9 @@ enum personal_state {
  * :param bool persistent: Indicates whether the configured personal state will remain set and active on pycardium application restart/change.
  * :returns: ``0`` on success, ``-EINVAL`` if an invalid state was requested.
  */
-API(API_PERSONAL_STATE_SET, int epic_personal_state_set(uint8_t state,
-                                                        bool persistent));
+API(API_PERSONAL_STATE_SET, int epic_personal_state_set(
+	uint8_t state, bool persistent
+));
 
 /**
  * Get the users personal state.
@@ -985,7 +1369,12 @@ enum bhi160_sensor_type {
 	 * - Dynamic range: g's (1x Earth Gravity, ~9.81m*s^-2)
 	 */
 	BHI160_ACCELEROMETER               = 0,
-	/** Magnetometer (**Unimplemented**) */
+	/**
+	 * Magnetometer
+	 *
+	 * - Data type: :c:type:`bhi160_data_vector`
+	 * - Dynamic range: -1000 to 1000 microtesla
+	 */
 	BHI160_MAGNETOMETER                = 1,
 	/** Orientation */
 	BHI160_ORIENTATION                 = 2,
@@ -1067,7 +1456,7 @@ struct bhi160_sensor_config {
 };
 
 /**
- * Enable a BHI160 virtual sensor.  Calling this funciton will instruct the
+ * Enable a BHI160 virtual sensor.  Calling this function will instruct the
  * BHI160 to collect data for this specific virtual sensor.  You can then
  * retrieve the samples using :c:func:`epic_stream_read`.
  *
@@ -1104,6 +1493,44 @@ API(API_BHI160_DISABLE, int epic_bhi160_disable_sensor(
  */
 API(API_BHI160_DISABLE_ALL, void epic_bhi160_disable_all_sensors());
 
+/**
+ * BHI160 Interrupt Handlers
+ * -------------------------
+ */
+
+/**
+ * **Interrupt Service Routine** for :c:data:`EPIC_INT_BHI160_ACCELEROMETER`
+ *
+ * :c:func:`epic_isr_bhi160_accelerometer` is called whenever the BHI160
+ * accelerometer has new data available.
+ */
+API_ISR(EPIC_INT_BHI160_ACCELEROMETER, epic_isr_bhi160_accelerometer);
+
+/**
+ * **Interrupt Service Routine** for :c:data:`EPIC_INT_BHI160_MAGNETOMETER`
+ *
+ * :c:func:`epic_isr_bhi160_magnetometer` is called whenever the BHI160
+ * magnetometer has new data available.
+ */
+API_ISR(EPIC_INT_BHI160_MAGNETOMETER, epic_isr_bhi160_magnetometer);
+
+/**
+ * **Interrupt Service Routine** for :c:data:`EPIC_INT_BHI160_ORIENTATION`
+ *
+ * :c:func:`epic_isr_bhi160_orientation` is called whenever the BHI160
+ * orientation sensor has new data available.
+ */
+API_ISR(EPIC_INT_BHI160_ORIENTATION, epic_isr_bhi160_orientation);
+
+/**
+ * **Interrupt Service Routine** for :c:data:`EPIC_INT_BHI160_GYROSCOPE`
+ *
+ * :c:func:`epic_isr_bhi160_orientation` is called whenever the BHI160
+ * gyroscrope has new data available.
+ */
+API_ISR(EPIC_INT_BHI160_GYROSCOPE, epic_isr_bhi160_gyroscope);
+
+
 /**
  * Vibration Motor
  * ===============
@@ -1220,8 +1647,8 @@ API(API_DISP_UPDATE, int epic_disp_update());
 /**
  * Prints a string into the display framebuffer
  *
- * :param posx: x position to print to. 0 <= x <= 160
- * :param posy: y position to print to. 0 <= y <= 80
+ * :param posx: x position to print to.
+ * :param posy: y position to print to.
  * :param pString: string to print
  * :param fg: foreground color in rgb565
  * :param bg: background color in rgb565
@@ -1231,13 +1658,56 @@ API(API_DISP_UPDATE, int epic_disp_update());
  */
 API(API_DISP_PRINT,
     int epic_disp_print(
-	    uint16_t posx,
-	    uint16_t posy,
+	    int16_t posx,
+	    int16_t posy,
 	    const char *pString,
 	    uint16_t fg,
 	    uint16_t bg)
     );
 
+/*
+ * Font Selection
+ */
+enum disp_font_name {
+	DISP_FONT8  = 0,
+	DISP_FONT12 = 1,
+	DISP_FONT16 = 2,
+	DISP_FONT20 = 3,
+	DISP_FONT24 = 4,
+};
+
+/*
+ * Image data type
+ */
+enum epic_rgb_format {
+	EPIC_RGB8     = 0,
+	EPIC_RGBA8    = 1,
+	EPIC_RGB565   = 2,
+	EPIC_RGBA5551 = 3,
+ };
+
+/**
+ * Prints a string into the display framebuffer with font type selectable
+ *
+ * :param fontName: number of font, use FontName enum
+ * :param posx: x position to print to.
+ * :param posy: y position to print to.
+ * :param pString: string to print
+ * :param fg: foreground color in rgb565
+ * :param bg: background color in rgb565, no background is drawn if bg==fg
+ * :return: ``0`` on success or a negative value in case of an error:
+ *
+ *    - ``-EBUSY``: Display was already locked from another task.
+ */
+API(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
+));
+
 /**
  * Fills the whole screen with one color
  *
@@ -1251,27 +1721,43 @@ API(API_DISP_CLEAR, int epic_disp_clear(uint16_t color));
 /**
  * Draws a pixel on the display
  *
- * :param x: x position; 0 <= x <= 160
- * :param y: y position; 0 <= y <= 80
+ * :param x: x position;
+ * :param y: y position;
  * :param color: pixel color in rgb565
  * :return: ``0`` on success or a negative value in case of an error:
  *
  *    - ``-EBUSY``: Display was already locked from another task.
  */
-API(API_DISP_PIXEL,
-    int epic_disp_pixel(
-	    uint16_t x,
-	    uint16_t y,
-	    uint16_t color)
-    );
+API(API_DISP_PIXEL, int epic_disp_pixel(
+	int16_t x, int16_t y, uint16_t color
+));
+
+/**
+ * Blits an image buffer to the display
+ *
+ * :param x: x position
+ * :param y: y position
+ * :param w: Image width
+ * :param h: Image height
+ * :param img: Image data
+ * :param format: Format of the image data. One of :c:type:`epic_rgb_format`.
+ */
+API(API_DISP_BLIT, int epic_disp_blit(
+	int16_t x,
+	int16_t y,
+	int16_t w,
+	int16_t h,
+	void *img,
+	enum epic_rgb_format format
+));
 
 /**
  * Draws a line on the display
  *
- * :param xstart: x starting position; 0 <= x <= 160
- * :param ystart: y starting position; 0 <= y <= 80
- * :param xend: x ending position; 0 <= x <= 160
- * :param yend: y ending position; 0 <= y <= 80
+ * :param xstart: x starting position
+ * :param ystart: y starting position
+ * :param xend: x ending position
+ * :param yend: y ending position
  * :param color: line color in rgb565
  * :param linestyle: 0 for solid, 1 for dottet (almost no visual difference)
  * :param pixelsize: thickness of the line; 1 <= pixelsize <= 8
@@ -1279,24 +1765,23 @@ API(API_DISP_PIXEL,
  *
  *    - ``-EBUSY``: Display was already locked from another task.
  */
-API(API_DISP_LINE,
-    int epic_disp_line(
-	    uint16_t xstart,
-	    uint16_t ystart,
-	    uint16_t xend,
-	    uint16_t yend,
+API(API_DISP_LINE, 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)
-    );
+	uint16_t pixelsize
+));
 
 /**
  * Draws a rectangle on the display
  *
- * :param xstart: x coordinate of top left corner; 0 <= x <= 160
- * :param ystart: y coordinate of top left corner; 0 <= y <= 80
- * :param xend: x coordinate of bottom right corner; 0 <= x <= 160
- * :param yend: y coordinate of bottom right corner; 0 <= y <= 80
+ * :param xstart: x coordinate of top left corner
+ * :param ystart: y coordinate of top left corner
+ * :param xend: x coordinate of bottom right corner
+ * :param yend: y coordinate of bottom right corner
  * :param color: line color in rgb565
  * :param fillstyle: 0 for empty, 1 for filled
  * :param pixelsize: thickness of the rectangle outline; 1 <= pixelsize <= 8
@@ -1304,16 +1789,15 @@ API(API_DISP_LINE,
  *
  *    - ``-EBUSY``: Display was already locked from another task.
  */
-API(API_DISP_RECT,
-    int epic_disp_rect(
-	    uint16_t xstart,
-	    uint16_t ystart,
-	    uint16_t xend,
-	    uint16_t yend,
+API(API_DISP_RECT, 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)
-    );
+	uint16_t pixelsize
+));
 
 /**
  * Draws a circle on the display
@@ -1328,15 +1812,14 @@ API(API_DISP_RECT,
  *
  *    - ``-EBUSY``: Display was already locked from another task.
  */
-API(API_DISP_CIRC,
-    int epic_disp_circ(
-	    uint16_t x,
-	    uint16_t y,
+API(API_DISP_CIRC, int epic_disp_circ(
+	int16_t x,
+	int16_t y,
 	uint16_t rad,
 	uint16_t color,
 	enum disp_fillstyle fillstyle,
-	    uint16_t pixelsize)
-    );
+	uint16_t pixelsize
+));
 
 /**
  * Immediately send the contents of a framebuffer to the display. This overrides
@@ -1347,28 +1830,36 @@ API(API_DISP_CIRC,
  *
  *    - ``-EBUSY``: Display was already locked from another task.
  */
-API(API_DISP_FRAMEBUFFER, int epic_disp_framebuffer(union disp_framebuffer *fb));
+API(API_DISP_FRAMEBUFFER, int epic_disp_framebuffer(
+	union disp_framebuffer *fb
+));
+
+
+/**
+ * Light Sensor
+ * ============
+ */
 
 
 /**
- * Set the backlight brightness value
+ * Set the backlight brightness.
  *
- * :param brightness: brightness from 0 - 100
- * :return: ``0`` on success or negative value in case of an error:
+ * Note that this function does not require acquiring the display.
  *
- *    - ``-EBUSY``: Display was already locked from another task.
+ * :param brightness: brightness from 0 - 100
+ * :return: ``0`` on success or negative value in case of an error
  */
 API(API_DISP_BACKLIGHT, int epic_disp_backlight(uint16_t brightness));
 
 
 /**
  * Start continuous readout of the light sensor. Will read light level
- * at preconfigured interval and make it available via `epic_light_sensor_get()`.
+ * at preconfigured interval and make it available via :c:func:`epic_light_sensor_get`.
  *
  * If the continuous readout was already running, this function will silently pass.
  *
  *
- * :return: `0` if the start was successful or a negative error value
+ * :return: ``0`` if the start was successful or a negative error value
  *      if an error occured. Possible errors:
  *
  *      - ``-EBUSY``: The timer could not be scheduled.
@@ -1379,7 +1870,7 @@ API(API_LIGHT_SENSOR_RUN, int epic_light_sensor_run());
  * Get the last light level measured by the continuous readout.
  *
  * :param uint16_t* value: where the last light level should be written.
- * :return: `0` if the readout was successful or a negative error
+ * :return: ``0`` if the readout was successful or a negative error
  *      value. Possible errors:
  *
  *      - ``-ENODATA``: Continuous readout not currently running.
@@ -1392,13 +1883,27 @@ API(API_LIGHT_SENSOR_GET, int epic_light_sensor_get(uint16_t* value));
  *
  * If the continuous readout wasn't running, this function will silently pass.
  *
- * :return: `0` if the stop was sucessful or a negative error value
+ * :return: ``0`` if the stop was sucessful or a negative error value
  *      if an error occured. Possible errors:
  *
  *      - ``-EBUSY``: The timer stop could not be scheduled.
  */
 API(API_LIGHT_SENSOR_STOP, int epic_light_sensor_stop());
 
+/**
+ * Get the light level directly.
+ *
+ * Each call has an intrinsic delay of about 240us, I recommend another
+ * 100-300us delay  between calls. Whether or not the IR LED is fast enough is
+ * another issue.
+ *
+ * :return: Light level
+ *
+ * .. versionadded:: 1.8
+ */
+API(API_LIGHT_SENSOR_READ, uint16_t epic_light_sensor_read(void));
+
+
 /**
  * File
  * ====
@@ -1434,10 +1939,9 @@ API(API_FILE_READ, int epic_file_read(int fd, void* buf, size_t nbytes));
  * :return: ``< 0`` on error, ``nbytes`` on success. (Partial writes don't occur on success!)
  *
 */
-API(
-	API_FILE_WRITE,
-	int epic_file_write(int fd, const void* buf, size_t nbytes)
-);
+API(API_FILE_WRITE, int epic_file_write(
+	int fd, const void* buf, size_t nbytes
+));
 
 /** */
 API(API_FILE_FLUSH, int epic_file_flush(int fd));
@@ -1581,11 +2085,42 @@ API(API_FILE_RENAME, int epic_file_rename(const char *oldp, const char* newp));
  */
 API(API_FILE_MKDIR, int epic_file_mkdir(const char *dirname));
 
+/**
+ * Check whether the filesystem is currently attached and a call like
+ * :c:func:`epic_file_open` has a chance to succeed.
+ *
+ * :return: ``true`` if the filesystem is attached and ``false`` if the
+ *     filesystem is not attached.
+ */
+API(API_FILE_FS_ATTACHED, bool epic_fs_is_attached(void));
+
 /**
  * RTC
  * ===
  */
 
+/**
+ * Get the monotonic time in seconds.
+ *
+ * :return: monotonic time in seconds
+ *
+ * .. versionadded:: 1.11
+ */
+API(API_RTC_GET_MONOTONIC_SECONDS,
+	uint32_t epic_rtc_get_monotonic_seconds(void)
+);
+
+/**
+ * Get the monotonic time in ms.
+ *
+ * :return: monotonic time in milliseconds
+ *
+ * .. versionadded:: 1.11
+ */
+API(API_RTC_GET_MONOTONIC_MILLISECONDS,
+	uint64_t epic_rtc_get_monotonic_milliseconds(void)
+);
+
 /**
  * Read the current RTC value.
  *
@@ -1603,13 +2138,15 @@ API(API_RTC_GET_MILLISECONDS, uint64_t epic_rtc_get_milliseconds(void));
 /**
  * Sets the current RTC time in milliseconds
  */
-API(API_RTC_SET_MILLISECONDS, void epic_rtc_set_milliseconds(uint64_t milliseconds));
+API(API_RTC_SET_MILLISECONDS, void epic_rtc_set_milliseconds(
+	uint64_t milliseconds
+));
 
 /**
  * Schedule the RTC alarm for the given timestamp.
  *
  * :param uint32_t timestamp: When to schedule the IRQ
- * :return: `0` on success or a negative value if an error occured. Possible
+ * :return: ``0`` on success or a negative value if an error occured. Possible
  *    errors:
  *
  *    - ``-EINVAL``: RTC is in a bad state
@@ -1617,7 +2154,7 @@ API(API_RTC_SET_MILLISECONDS, void epic_rtc_set_milliseconds(uint64_t millisecon
 API(API_RTC_SCHEDULE_ALARM, int epic_rtc_schedule_alarm(uint32_t timestamp));
 
 /**
- * **Interrupt Service Routine**
+ * **Interrupt Service Routine** for :c:data:`EPIC_INT_RTC_ALARM`
  *
  * ``epic_isr_rtc_alarm()`` is called when the RTC alarm triggers.  The RTC alarm
  * can be scheduled using :c:func:`epic_rtc_schedule_alarm`.
@@ -1625,22 +2162,49 @@ API(API_RTC_SCHEDULE_ALARM, int epic_rtc_schedule_alarm(uint32_t timestamp));
 API_ISR(EPIC_INT_RTC_ALARM, epic_isr_rtc_alarm);
 
 /**
- * TRNG
+ * RNG
  * ====
  */
 
 /**
  * Read random bytes from the TRNG.
  *
+ * Be aware that this function returns raw unprocessed bytes from
+ * the TRNG. They might be biased or have other kinds of imperfections.
+ *
+ * Use :c:func:`epic_csprng_read` for cryptographically safe random
+ * numbers instead.
+ *
+ * .. warning::
+ *
+ *    The exact behaviour of the TRNG is not well understood. Its
+ *    distribution and other parameters are unknown. Only use this
+ *    function if you really want the unmodified values from the
+ *    hardware TRNG to experiment with it.
+ *
  * :param uint8_t * dest: Destination buffer
  * :param size: Number of bytes to read.
- * :return: `0` on success or a negative value if an error occured. Possible
+ * :return: ``0`` on success or a negative value if an error occured. Possible
  *    errors:
  *
  *    - ``-EFAULT``: Invalid destination address.
  */
 API(API_TRNG_READ, int epic_trng_read(uint8_t *dest, size_t size));
 
+/**
+ * Read random bytes from the CSPRNG.
+ *
+ * The random bytes returned are safe to be used for cryptography.
+ *
+ * :param uint8_t * dest: Destination buffer
+ * :param size: Number of bytes to read.
+ * :return: ``0`` on success or a negative value if an error occured. Possible
+ *    errors:
+ *
+ *    - ``-EFAULT``: Invalid destination address.
+ */
+API(API_CSPRNG_READ, int epic_csprng_read(uint8_t *dest, size_t size));
+
 /**
  * MAX30001
  * ========
@@ -1678,9 +2242,10 @@ struct max30001_sensor_config {
 };
 
 /**
- * Enable a MAX30001 ecg sensor.  Calling this funciton will instruct the
- * MAX30001 to collect data for this sensor.  You can then
- * retrieve the samples using :c:func:`epic_stream_read`.
+ * Enable a MAX30001 ECG sensor.
+ *
+ * Calling this function will instruct the MAX30001 to collect data for this
+ * sensor.  You can then retrieve the samples using :c:func:`epic_stream_read`.
  *
  * :param max30001_sensor_config* config: Configuration for this sensor.
  * :returns: A sensor descriptor which can be used with
@@ -1700,24 +2265,502 @@ API(API_MAX30001_ENABLE, int epic_max30001_enable_sensor(
  *
  * .. versionadded:: 1.6
  */
-API(API_MAX30001_DISABLE, int epic_max30001_disable_sensor(
-void
-));
+API(API_MAX30001_DISABLE, int epic_max30001_disable_sensor());
+
+/**
+ * **Interrupt Service Routine** for :c:data:`EPIC_INT_MAX30001_ECG`
+ *
+ * This interrupt handler is called whenever the MAX30001 ECG has new data
+ * available.
+ */
+API_ISR(EPIC_INT_MAX30001_ECG, epic_isr_max30001_ecg);
+
+/**
+ * USB
+ * ===
+ */
 
 /**
  * De-initialize the currently configured USB device (if any)
  *
  */
 API(API_USB_SHUTDOWN, int epic_usb_shutdown(void));
+
 /**
  * Configure the USB peripheral to export the internal FLASH
- * as a Mass Storage device
+ * as a Mass Storage device.
  */
 API(API_USB_STORAGE, int epic_usb_storage(void));
+
 /**
  * Configure the USB peripheral to provide card10's stdin/stdout
- * on a USB CDC-ACM device
+ * on a USB CDC-ACM device.
  */
 API(API_USB_CDCACM, int epic_usb_cdcacm(void));
 
+/**
+ * WS2812
+ * ======
+ */
+
+/**
+ * Takes a gpio pin specified with the gpio module and transmits
+ * the led data. The format ``GG:RR:BB`` is expected.
+ *
+ * :param uint8_t pin: The gpio pin to be used for data.
+ * :param uint8_t * pixels: The buffer, in which the pixel data is stored.
+ * :param uint32_t n_bytes: The size of the buffer.
+ *
+ * .. versionadded:: 1.10
+ */
+API(API_WS2812_WRITE, void epic_ws2812_write(uint8_t pin, uint8_t *pixels, uint32_t n_bytes));
+
+
+/**
+ * Configuration
+ * =============
+ */
+
+/**
+ * Read an integer from the configuration file
+ *
+ * :param char* key: Name of the option to read
+ * :param int* value: Place to read the value into
+ * :return: ``0`` on success or a negative value if an error occured. Possible
+ *    errors:
+ *
+ *    - ``-ENOENT``: Value can not be read
+ *
+ * .. versionadded:: 1.13
+ */
+API(API_CONFIG_GET_INTEGER, int epic_config_get_integer(const char *key, int *value));
+
+/**
+ * Read a boolean from the configuration file
+ *
+ * :param char* key: Name of the option to read
+ * :param bool* value: Place to read the value into
+ * :return: ``0`` on success or a negative value if an error occured. Possible
+ *    errors:
+ *
+ *    - ``-ENOENT``: Value can not be read
+ *
+ * .. versionadded:: 1.13
+ */
+API(API_CONFIG_GET_BOOLEAN, int epic_config_get_boolean(const char *key, bool *value));
+
+/**
+ * Read a string from the configuration file.
+ *
+ * If the buffer supplied is too small for the config option,
+ * no error is reported and the first ``buf_len - 1`` characters
+ * are returned (0 terminated).
+ *
+ * :param char* key: Name of the option to read
+ * :param char* buf: Place to read the string into
+ * :param size_t buf_len: Size of the provided buffer
+ * :return: ``0`` on success or a negative value if an error occured. Possible
+ *    errors:
+ *
+ *    - ``-ENOENT``: Value can not be read
+ *
+ * .. versionadded:: 1.13
+ */
+API(API_CONFIG_GET_STRING, int epic_config_get_string(const char *key, char *buf, size_t buf_len));
+
+
+/**
+ * Write a string to the configuration file.
+ *
+ * :param char* key: Name of the option to write
+ * :param char* value: The value to write
+ * :return: ``0`` on success or a negative value if an error occured. Possivle
+ *    errors:
+ *
+ *    - ``-EINVAL``: Parameters out of range
+ *    - ``-ENOENT``: Key already exists but can not be read
+ *    - ``-EIO``   : Unspecified I/O error
+ *    - Any fopen/fread/fwrite/fclose related error code
+ *
+ * .. versionadded:: 1.16
+ */
+API(API_CONFIG_SET_STRING, int epic_config_set_string(const char *key, const char *value));
+
+
+/**
+ * Bluetooth Low Energy (BLE)
+ * ==========================
+ */
+
+/**
+ * BLE event type
+ */
+enum epic_ble_event_type {
+	/** No event pending */
+	BLE_EVENT_NONE                                    = 0,
+	/** Numeric comparison requested */
+	BLE_EVENT_HANDLE_NUMERIC_COMPARISON               = 1,
+	/** A pairing procedure has failed */
+	BLE_EVENT_PAIRING_FAILED                          = 2,
+	/** A pairing procedure has successfully completed */
+	BLE_EVENT_PAIRING_COMPLETE                        = 3,
+	/** New scan data is available  */
+	BLE_EVENT_SCAN_REPORT                             = 4,
+	BLE_EVENT_ATT_EVENT                               = 5,
+	BLE_EVENT_ATT_WRITE                               = 6,
+	BLE_EVENT_DM_EVENT                                = 7,
+};
+
+/**
+ * MicroPython Bluetooth support data types. Please
+ * do not use them until they are stabilized.
+ */
+typedef uint8_t bdAddr_t[6];
+
+struct epic_wsf_header
+{
+	/** General purpose parameter passed to event handler */
+	uint16_t param;
+	/** General purpose event value passed to event handler */
+	uint8_t event;
+	/** General purpose status value passed to event handler */
+	uint8_t status;
+};
+
+struct epic_att_event
+{
+	/** Header structure */
+	struct epic_wsf_header hdr;
+	/** Value */
+	uint8_t *pValue;
+	/** Value length */
+	uint16_t valueLen;
+	/** Attribute handle */
+	uint16_t handle;
+	/** TRUE if more response packets expected */
+	uint8_t continuing;
+	/** Negotiated MTU value */
+	uint16_t mtu;
+};
+
+struct epic_hciLeConnCmpl_event
+{        /** Event header */
+	struct epic_wsf_header hdr;
+	/** Status. */
+	uint8_t status;
+	/** Connection handle. */
+	uint16_t handle;
+	/** Local connection role. */
+	uint8_t role;
+	/** Peer address type. */
+	uint8_t addrType;
+	/** Peer address. */
+	bdAddr_t peerAddr;
+	/** Connection interval */
+	uint16_t connInterval;
+	/** Connection latency. */
+	uint16_t connLatency;
+	/** Supervision timeout. */
+	uint16_t supTimeout;
+	/** Clock accuracy. */
+	uint8_t clockAccuracy;
+
+	/** enhanced fields */
+	/** Local RPA. */
+	bdAddr_t localRpa;
+	/** Peer RPA. */
+	bdAddr_t peerRpa;
+};
+
+/*! \brief Disconnect complete event */
+struct epic_hciDisconnectCmpl_event
+{
+	/** Event header */
+	struct epic_wsf_header hdr;
+	/** Disconnect complete status. */
+	uint8_t status;
+	/** Connect handle. */
+	uint16_t handle;
+	/** Reason. */
+	uint8_t reason;
+};
+
+struct epic_dm_event
+{
+	union {
+		/** LE connection complete. */
+		struct epic_hciLeConnCmpl_event leConnCmpl;
+		/** Disconnect complete. */
+		struct epic_hciDisconnectCmpl_event disconnectCmpl;
+	};
+};
+
+struct epic_att_write
+{
+	/** Header structure */
+	struct epic_wsf_header hdr;
+	/** Value length */
+	uint16_t valueLen;
+	/** Attribute handle */
+	uint16_t handle;
+
+	uint8_t operation;
+	uint16_t offset;
+	void *buffer;
+};
+
+struct epic_ble_event {
+	enum epic_ble_event_type type;
+	union {
+		void *data;
+		struct epic_att_event *att_event;
+		struct epic_dm_event *dm_event;
+		struct epic_att_write *att_write;
+	};
+};
+
+/**
+ * Scan report data. Based on ``hciLeAdvReportEvt_t`` from BLE stack.
+ *
+ * TODO: 64 bytes for data is an arbitrary number ATM */
+struct epic_scan_report
+{
+	/** advertising or scan response data. */
+	uint8_t data[64];
+	/** length of advertising or scan response data. */
+	uint8_t len;
+	/** RSSI. */
+	int8_t rssi;
+	/** Advertising event type. */
+	uint8_t eventType;
+	/** Address type. */
+	uint8_t addrType;
+	/** Device address. */
+	uint8_t addr[6];
+
+	/** direct fields */
+	/** Direct advertising address type. */
+	uint8_t directAddrType;
+	/** Direct advertising address. */
+	uint8_t directAddr[6];
+};
+
+/**
+ * **Interrupt Service Routine** for :c:data:`EPIC_INT_BLE`
+ *
+ * :c:func:`epic_isr_ble` is called when the BLE stack wants to signal an
+ * event to the application. You can use :c:func:`epic_ble_get_event` to obtain
+ * the event which triggered this interrupt.
+ *
+ * Currently supported events:
+ *
+ * :c:data:`BLE_EVENT_HANDLE_NUMERIC_COMPARISON`:
+ *    An ongoing pairing procedure requires a numeric comparison to complete.
+ *    The compare value can be retreived using :c:func:`epic_ble_get_compare_value`.
+ *
+ * :c:data:`BLE_EVENT_PAIRING_FAILED`:
+ *    A pairing procedure failed. The stack automatically went back advertising
+ *    and accepting new pairings.
+ *
+ * :c:data:`BLE_EVENT_PAIRING_COMPLETE`:
+ *    A pairing procedure has completed sucessfully.
+ *    The stack automatically persists the pairing information, creating a bond.
+ *
+ * .. versionadded:: 1.16
+ */
+API_ISR(EPIC_INT_BLE, epic_isr_ble);
+
+/**
+ * Retreive the event which triggered :c:func:`epic_isr_ble`
+ *
+ * .. versionadded:: 1.16
+ * .. versionchanged:: 1.17
+ */
+API(API_BLE_GET_EVENT, int epic_ble_get_event(struct epic_ble_event *e));
+
+/**
+ * Retrieve the compare value of an ongoing pairing procedure.
+ *
+ * If no pairing procedure is ongoing, the returned value is undefined.
+ *
+ * :return: 6 digit long compare value
+ *
+ * .. versionadded:: 1.16
+ */
+API(API_BLE_GET_COMPARE_VALUE, uint32_t epic_ble_get_compare_value(void));
+
+/**
+ * Retrieve the (file) name of the last pairing which was successful.
+ *
+ * :return: ``0`` on success or a negative value if an error occured. Possible
+ *    errors:
+ *
+ *    - ``-ENOENT``: There was no successful pairing yet.
+ *
+ * .. versionadded:: 1.16
+ */
+API(API_BLE_GET_LAST_PAIRING_NAME, int epic_ble_get_last_pairing_name(char *buf, size_t buf_size));
+
+/**
+ * Retrieve the name of the peer to which we are connected
+ *
+ * The name might be empty if the peer device does not expose it or
+ * if it has not yet been read from it.
+ *
+ * :return: ``0`` on success or a negative value if an error occured. Possible
+ *    errors:
+ *
+ *    - ``-ENOENT``: There is no active connection at the moment.
+ *
+ * .. versionadded:: 1.16
+ */
+API(API_BLE_GET_PEER_DEVICE_NAME, int epic_ble_get_peer_device_name(char *buf, size_t buf_size));
+
+/**
+ * Indicate wether the user confirmed the compare value.
+ *
+ * If a pariring procedure involving a compare value is ongoing and this
+ * function is called with confirmed set to ``true``, it will try to
+ * proceed and complete the pairing process. If called with ``false``, the
+ * pairing procedure will be aborted.
+ *
+ * :param bool confirmed: ``true`` if the user confirmed the compare value.
+ *
+ * .. versionadded:: 1.16
+ */
+API(API_BLE_COMPARE_RESPONSE, void epic_ble_compare_response(bool confirmed));
+
+/**
+ * Set the desired mode of the BLE stack.
+ *
+ * There are three allowed modes:
+ *
+ *  - Peripheral which is not bondable (bondable = ``false``, scanner = ``false``).
+ *  - Peripheral which is bondable (bondable = ``true``, scanner = ``false``).
+ *  - Observer which scans for advertisements (bondable = ``false``, scanner = ``true``).
+ *
+ * By default the card10 will not allow new bondings to be made. New
+ * bondings have to explicitly allowed by calling this function.
+ *
+ * While bondable the card10 will change its advertisements to
+ * indicate to scanning hosts that it is available for discovery.
+ *
+ * When scanning is active, :c:data:`BLE_EVENT_SCAN_REPORT` events will be sent
+ * and the scan reports can be fetched using :c:func:`epic_ble_get_scan_report`.
+ *
+ * When switching applications new bondings are automatically
+ * disallowed and scanning is stopped.
+ *
+ * :param bool bondable: ``true`` if new bondings should be allowed.
+ * :param bool scanner: ``true`` if scanning should be turned on.
+ *
+ * .. versionadded:: 1.16
+ */
+API(API_BLE_SET_MODE, void epic_ble_set_mode(bool bondable, bool scanner));
+
+/**
+ * Retrieve a scan report from the queue of scan reports.
+ *
+ * :param struct\ epic_scan_report* rpt: Pointer where the report will be stored.
+ *
+ * :return: ``0`` on success or a negative value if an error occured. Possible
+ *    errors:
+ *
+ *    - ``-ENOENT``: No scan report available
+ *
+ */
+API(API_BLE_GET_SCAN_REPORT, int epic_ble_get_scan_report(struct epic_scan_report *rpt));
+
+/**
+ * Send an input report to the host.
+ *
+ * :param uint8_t report_id: The id of the report to use. 1: keyboard, 2: mouse, 3: consumer control
+ * :param uint8_t* data: Data to be reported.
+ * :param uint8_t len: Length in bytes of the data to be reported. Maximum length is 8 bytes.
+ *
+ * :return: ``0`` on success, ``1`` if the report is queued or a negative value
+ *    if an error occured. Possible errors:
+ *
+ *    - ``-EIO``: There is no host device connected or BLE HID is not enabled.
+ *    - ``-EAGAIN``: There is no space in the queue available. Try again later.
+ *    - ``-EINVAL``: Either the report_id is out of range or the data is too long.
+ *
+ */
+API(API_BLE_HID_SEND_REPORT, int epic_ble_hid_send_report(uint8_t report_id, uint8_t *data, uint8_t len));
+
+
+/**
+ * MicroPython BLE Support API
+ * ---------------------------
+ * The following API calls are to be used for MicroPython BLE support.
+ *
+ * .. warning::
+ *
+ *    The following epic-calls are **not** part of the stable public API and
+ *    thus **no** guarantee about stability or behavior is made.  Do not use
+ *    these outside of Pycardium unless you can live with sudden breakage!!
+ *
+ *    They are only documented here for completeness and as a reference for
+ *    firmware hackers, not for common usage.
+ */
+
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_INIT, int epic_ble_init(void));
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_DEINIT, int epic_ble_deinit(void));
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_ATTS_DYN_CREATE_GROUP, int epic_atts_dyn_create_service(const uint8_t *uuid, uint8_t uuid_len, uint16_t group_size, void **pSvcHandle));
+//API(API_BLE_ATTS_DYN_DELETE_GROUP, void AttsDynDeleteGroup(void *pSvcHandle));
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_ATTS_DYN_DELETE_GROUPS, int epic_ble_atts_dyn_delete_groups(void));
+
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_ATTS_DYN_ADD_CHARACTERISTIC, int epic_atts_dyn_add_characteristic(void *pSvcHandle, const uint8_t *uuid, uint8_t uuid_len, uint8_t flags, uint16_t maxLen, uint16_t *value_handle));
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_ATTS_DYN_ADD_DESCRIPTOR, int epic_ble_atts_dyn_add_descriptor(void *pSvcHandle, const uint8_t *uuid, uint8_t uuid_len, uint8_t flags, const uint8_t *value, uint16_t value_len, uint16_t maxLen, uint16_t *descriptor_handle));
+
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_ATTS_SEND_SERVICE_CHANGED_IND, int epic_atts_dyn_send_service_changed_ind(void));
+
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_ATTS_SET_ATTR, int epic_ble_atts_set_attr(uint16_t handle, const uint8_t *value, uint16_t value_len));
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_ATTS_HANDLE_VALUE_NTF, int epic_ble_atts_handle_value_ntf(uint8_t connId, uint16_t handle, uint16_t valueLen, uint8_t *pValue));
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_ATTS_HANDLE_VALUE_IND, int epic_ble_atts_handle_value_ind(uint8_t connId, uint16_t handle, uint16_t valueLen, uint8_t *pValue));
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_ATTS_SET_BUFFER, int epic_ble_atts_set_buffer(uint16_t value_handle, size_t len, bool append));
+
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_FREE_EVENT, int epic_ble_free_event(struct epic_ble_event *e));
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_CLOSE_CONNECTION, void epic_ble_close_connection(uint8_t connId));
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_IS_CONNECTION_OPEN, int epic_ble_is_connection_open(void));
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_SET_DEVICE_NAME, int epic_ble_set_device_name(const uint8_t *buf, uint16_t len));
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_GET_DEVICE_NAME, int epic_ble_get_device_name(uint8_t **buf, uint16_t *len));
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_GET_ADDRESS, void epic_ble_get_address(uint8_t *addr));
+
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_ADVERTISE, int epic_ble_advertise(int interval_us, const uint8_t *adv_data, size_t adv_data_len, const uint8_t *sr_data, size_t sr_data_len, bool connectable));
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_ADVERTISE_STOP, int epic_ble_advertise_stop(void));
+
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_DISCOVER_PRIMARY_SERVICES, int epic_ble_attc_discover_primary_services(uint8_t connId, const uint8_t *uuid, uint8_t uuid_len));
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_DISCOVER_CHARACTERISTICS, int epic_ble_attc_discover_characteristics(uint8_t connId, uint16_t start_handle, uint16_t end_handle));
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_DISCOVER_DESCRIPTORS, int epic_ble_attc_discover_descriptors(uint8_t connId, uint16_t start_handle, uint16_t end_handle));
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_ATTC_READ, int epic_ble_attc_read(uint8_t connId, uint16_t value_handle));
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_ATTC_WRITE_NO_RSP, int epic_ble_attc_write_no_rsp(uint8_t connId, uint16_t value_handle, const uint8_t *value, uint16_t value_len));
+/** Private API call for Pycardium BLE support. */
+API(API_BLE_ATTC_WRITE, int epic_ble_attc_write(uint8_t connId, uint16_t value_handle, const uint8_t *value, uint16_t value_len));
+
 #endif /* _EPICARDIUM_H */
+