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,9 +140,59 @@ 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 */
 
@@ -142,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.
  */
 
 /**
@@ -158,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:
  */
@@ -169,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 */
 
 /*
@@ -244,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
  * ===============
@@ -297,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
 ));
 
 /**
@@ -324,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
@@ -354,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
@@ -453,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),
@@ -481,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.
@@ -576,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.
  *
@@ -588,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.
@@ -611,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.
@@ -624,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.
@@ -637,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.
@@ -701,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.
  *
@@ -720,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
 ));
 
 /**
@@ -731,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
@@ -798,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
@@ -842,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.
@@ -981,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,
@@ -1063,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`.
  *
@@ -1100,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
  * ===============
@@ -1216,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
@@ -1227,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
  *
@@ -1247,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
@@ -1275,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
@@ -1300,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
@@ -1324,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
@@ -1343,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
+));
 
 
 /**
- * Set the backlight brightness value
+ * Light Sensor
+ * ============
+ */
+
+
+/**
+ * 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.
@@ -1375,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.
@@ -1388,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
  * ====
@@ -1430,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));
@@ -1577,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.
  *
@@ -1599,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
@@ -1613,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`.
@@ -1621,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
  * ========
@@ -1674,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
@@ -1696,9 +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.
+ */
+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.
+ */
+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 */
+

epicardium/modules/fileops.c → epicardium/fs/fileops.c

@@ -29,6 +29,17 @@ int epic_file_open(const char *filename, const char *mode)
 	return res;
 }
 
+bool epic_fs_is_attached(void)
+{
+	EpicFileSystem *fs;
+	if (efs_lock_global(&fs) == 0) {
+		efs_unlock_global(fs);
+		return true;
+	} else {
+		return false;
+	}
+}
+
 int epic_file_close(int fd)
 {
 	EpicFileSystem *fs;

epicardium/modules/filesystem.h → epicardium/fs/filesystem.h

@@ -16,9 +16,19 @@ void fatfs_init(void);
 
 /**
  * initialize and mount the FLASH storage
+ *
+ * NOTE: not safe to be called from an ISR
  */
 int fatfs_attach(void);
 
+
+/**
+ * asynchronously attach the FLASH storage
+ *
+ * safe to be called from an ISR
+ */
+void fatfs_schedule_attach(void);
+
 /** close all opened FDs, sync and deinitialize FLASH layer */
 void fatfs_detach(void);
 

epicardium/fs/filesystem_fat.c

@@ -16,23 +16,22 @@
 
 #include <FreeRTOS.h>
 #include <semphr.h>
+#include <timers.h>
 
 #include "fs/internal.h"
-#include "modules/filesystem.h"
+#include "fs/filesystem.h"
+#include "user_core/user_core.h"
 #include "epicardium.h"
 #include "card10.h"
-#include "modules/log.h"
+#include "os/core.h"
 #include "modules/modules.h"
 #include "api/common.h"
+#include "os/mutex.h"
 
 #define SSLOG_DEBUG(...) LOG_DEBUG("fatfs", __VA_ARGS__)
 #define SSLOG_INFO(...) LOG_INFO("fatfs", __VA_ARGS__)
 #define SSLOG_ERR(...) LOG_ERR("fatfs", __VA_ARGS__)
 
-#ifndef EPIC_FAT_STATIC_SEMAPHORE
-#define EPIC_FAT_STATIC_SEMAPHORE 0
-#endif
-
 /* clang-format off */
 #define EPIC_FAT_MAX_OPENED           (1 << (EPIC_FAT_FD_INDEX_BITS))
 #define EPIC_FAT_FD_GENERATION_BITS   (31 - (EPIC_FAT_FD_INDEX_BITS))
@@ -57,7 +56,7 @@ struct FatObject {
 struct EpicFileSystem {
 	struct FatObject pool[EPIC_FAT_MAX_OPENED];
 	uint32_t generationCount;
-	bool initialized;
+	bool attached;
 	FATFS FatFs;
 	int lockCoreMask;
 };
@@ -66,8 +65,6 @@ struct EpicFileSystem {
 static const int s_libffToErrno[20];
 
 static const char *f_get_rc_string(FRESULT rc);
-static bool globalLockAccquire();
-static void globalLockRelease();
 static void efs_close_all(EpicFileSystem *fs, int coreMask);
 
 /**
@@ -96,11 +93,12 @@ static void efs_init_stat(struct epic_stat *stat, FILINFO *finfo);
 
 static EpicFileSystem s_globalFileSystem;
 
-#if (EPIC_FAT_STATIC_SEMAPHORE == 1)
-static StaticSemaphore_t s_globalLockBuffer;
-#endif
+static struct mutex fatfs_lock = { 0 };
 
-static SemaphoreHandle_t s_globalLock = NULL;
+static void cb_attachTimer(void *a, uint32_t b)
+{
+	fatfs_attach();
+}
 
 void fatfs_init()
 {
@@ -112,11 +110,8 @@ void fatfs_init()
 	assert(!s_initCalled);
 	s_initCalled = true;
 
-#if (EPIC_FAT_STATIC_SEMAPHORE == 1)
-	s_globalLock = xSemaphoreCreateMutexStatic(&s_globalLockBuffer);
-#else
-	s_globalLock = xSemaphoreCreateMutex();
-#endif
+	mutex_create(&fatfs_lock);
+
 	s_globalFileSystem.generationCount = 1;
 	fatfs_attach();
 }
@@ -135,27 +130,36 @@ int fatfs_attach()
 {
 	FRESULT ff_res;
 	int rc = 0;
-	if (globalLockAccquire()) {
+
+	mutex_lock(&fatfs_lock);
+
 	EpicFileSystem *fs = &s_globalFileSystem;
-		if (!fs->initialized) {
+	if (!fs->attached) {
 		ff_res = f_mount(&fs->FatFs, "/", 0);
 		if (ff_res == FR_OK) {
-				fs->initialized = true;
-				SSLOG_DEBUG("FatFs mounted\n");
+			fs->attached = true;
+			SSLOG_INFO("attached\n");
 		} else {
 			SSLOG_ERR(
-					"f_mount error %s\n",
-					f_get_rc_string(ff_res)
+				"f_mount error %s\n", f_get_rc_string(ff_res)
 			);
 			rc = -s_libffToErrno[ff_res];
 		}
 	}
 
-		globalLockRelease();
+	mutex_unlock(&fatfs_lock);
+	return rc;
+}
+
+void fatfs_schedule_attach(void)
+{
+	//if we're running in thread context, cont't call the *FromISR version
+	if (xPortIsInsideInterrupt()) {
+		xTimerPendFunctionCallFromISR(cb_attachTimer, NULL, 0, NULL);
 	} else {
-		SSLOG_ERR("Failed to lock\n");
+		xTimerPendFunctionCall(
+			cb_attachTimer, NULL, 0, 1); //wait 1 tick
 	}
-	return rc;
 }
 
 void fatfs_detach()
@@ -163,6 +167,7 @@ void fatfs_detach()
 	FRESULT ff_res;
 	EpicFileSystem *fs;
 	if (efs_lock_global(&fs) == 0) {
+		if (fs->attached) {
 			efs_close_all(fs, EPICARDIUM_COREMASK_BOTH);
 
 			//unmount by passing NULL as fs object, will destroy our sync object via ff_del_syncobj
@@ -174,9 +179,10 @@ void fatfs_detach()
 				);
 			}
 
-		fs->initialized = false;
+			fs->attached = false;
 			disk_deinitialize();
 			SSLOG_INFO("detached\n");
+		}
 		efs_unlock_global(fs);
 	}
 }
@@ -207,24 +213,12 @@ static const char *f_get_rc_string(FRESULT rc)
 	return p;
 }
 
-static bool globalLockAccquire()
-{
-	return (int)(xSemaphoreTake(s_globalLock, FF_FS_TIMEOUT) == pdTRUE);
-}
-
-static void globalLockRelease()
-{
-	xSemaphoreGive(s_globalLock);
-}
-
 int efs_lock_global(EpicFileSystem **fs)
 {
 	*fs = NULL;
-	if (!globalLockAccquire()) {
-		return -EBUSY;
-	}
-	if (!s_globalFileSystem.initialized) {
-		globalLockRelease();
+	mutex_lock(&fatfs_lock);
+	if (!s_globalFileSystem.attached) {
+		mutex_unlock(&fatfs_lock);
 		return -ENODEV;
 	}
 	*fs = &s_globalFileSystem;
@@ -239,7 +233,7 @@ int efs_lock_global(EpicFileSystem **fs)
 void efs_unlock_global(EpicFileSystem *fs)
 {
 	(void)fs;
-	globalLockRelease();
+	mutex_unlock(&fatfs_lock);
 }
 
 static bool efs_get_opened(
@@ -292,6 +286,7 @@ efs_get_new(EpicFileSystem *fs, uint32_t *idx, struct FatObject **obj, int *rc)
 	}
 
 	*obj = &fs->pool[index];
+	*idx = index;
 	return true;
 }
 

epicardium/fs/fs_util.c

+#include "fs_util.h"
+
+#include "epicardium.h"
+
+#include <stdint.h>
+#include <string.h>
+
+int fs_read_file(char *filename, void *data, int len)
+{
+	int fd = epic_file_open(filename, "r");
+	if (fd < 0) {
+		return fd;
+	}
+
+	int res = epic_file_read(fd, data, len);
+	epic_file_close(fd);
+
+	return res;
+}
+
+int fs_read_text_file(char *filename, char *data, int len)
+{
+	int readbytes;
+
+	if (len < 1)
+		return -1;
+	readbytes = fs_read_file(filename, data, len - 1);
+	if (readbytes < 0) {
+		data[0] = 0;
+		return readbytes;
+	};
+	data[readbytes] = 0;
+	while (readbytes > 0 && data[readbytes - 1] < 0x20) {
+		data[--readbytes] = 0;
+	};
+	return readbytes;
+}
+
+int fs_write_file(char *filename, const void *data, int len)
+{
+	int fd = epic_file_open(filename, "w");
+	if (fd < 0) {
+		return fd;
+	}
+
+	int res = epic_file_write(fd, data, len);
+	epic_file_close(fd);
+
+	return res;
+}
+
+int fs_get_file_size(char *filename)
+{
+	struct epic_stat stat;
+	int res = epic_file_stat(filename, &stat);
+	return res < 0 ? res : (int)stat.size;
+}
+
+#if 0
+#include "ff.h"
+FATFS FatFs;          /* File system object for logical drive */
+FS_USAGE FsUsage;
+/* TODO: Port functions from r0ket/rad10 libs */
+int fs_info(FATFS *fs)
+{
+    memcpy(fs, &FatFs, sizeof(FATFS));
+    return 0;
+}
+int fs_usage(FATFS *fs, FS_USAGE *fs_usage)
+{
+    FRESULT res;
+    DWORD tot_clust, fre_clust, sec_size;
+
+    res = f_getfree("/", &fre_clust, &fs);
+    if(res != FR_OK)
+        return -res;
+
+    // sectore size = sectors per cluster *  sector size
+#if FF_MAX_SS == FF_MIN_SS
+    sec_size = fs->csize * FF_MAX_SS;
+#else
+    sec_size = fs->csize * fs.ssize;
+#endif
+
+    // total/free sectors * sectore size
+    tot_clust = fs->n_fatent - 2;
+    fs_usage->total = tot_clust * sec_size; //FatFs.ssize;
+    fs_usage->free = fre_clust * sec_size; //FatFs.ssize;
+
+    return 0;
+}
+#endif

epicardium/fs/meson.build

+fs_sources = files(
+  'fileops.c',
+  'filesystem_fat.c',
+  'fs_util.c',
+)

epicardium/l0der/l0der.c

@@ -6,7 +6,7 @@
 
 #include "epicardium.h"
 #include "l0der/elf.h"
-#include "modules/log.h"
+#include "os/core.h"
 
 /*
  * l0der is, in reality, a boneless operating-system style ELF loader.
@@ -119,7 +119,7 @@ static int _seek_and_read(int fd, uint32_t address, void *data, size_t count)
 		return res;
 	}
 
-	if ((res = epic_file_read(fd, data, count)) != count) {
+	if ((size_t)(res = epic_file_read(fd, data, count)) != count) {
 		LOG_ERR("l0der", "_seek_and_read: could not read: %d", res);
 		return res;
 	}
@@ -149,7 +149,7 @@ static int _read_section_header(int fd, uint32_t shdr_addr, Elf32_Shdr *shdr)
  * This function ensures basic memory sanity of a program header / segment.
  * It ensures that it points to a file region that is contained within the file fully.
  */
-static int _check_program_header(int fd, int size, Elf32_Phdr *phdr)
+static int _check_program_header(int fd, size_t size, Elf32_Phdr *phdr)
 {
 	// Check file size/offset.
 	uint32_t file_start = phdr->p_offset;
@@ -191,7 +191,7 @@ static int _check_program_header(int fd, int size, Elf32_Phdr *phdr)
  * This function ensures basic memory sanity of a section header.
  * It ensures that it points to a file region that is contained within the file fully.
  */
-static int _check_section_header(int fd, int size, Elf32_Shdr *shdr)
+static int _check_section_header(int fd, size_t size, Elf32_Shdr *shdr)
 {
 	// Check file size/offset.
 	uint32_t file_start = shdr->sh_offset;
@@ -329,7 +329,7 @@ static int _load_segment(int fd, struct _pie_load_info *li, Elf32_Phdr *phdr)
  * Parse dynamic symbol sections.
  */
 static int _parse_dynamic_symbols(
-	int fd, int size, struct _pie_load_info *li, Elf32_Ehdr *hdr
+	int fd, size_t size, struct _pie_load_info *li, Elf32_Ehdr *hdr
 ) {
 	int res;
 	Elf32_Shdr shdr;
@@ -366,7 +366,7 @@ static int _parse_dynamic_symbols(
 			return res;
 		}
 
-		for (int j = 0; j < sym_count; j++) {
+		for (uint32_t j = 0; j < sym_count; j++) {
 			if ((res = epic_file_read(
 				     fd, &sym, sizeof(Elf32_Sym))) !=
 			    sizeof(Elf32_Sym)) {
@@ -402,9 +402,9 @@ static int _parse_dynamic_symbols(
  * the only one used when making 'standard' PIE binaries on RAM. However, other
  * kinds might have to be implemented in the future.
  */
-static int
-_run_relocations(int fd, int size, struct _pie_load_info *li, Elf32_Ehdr *hdr)
-{
+static int _run_relocations(
+	int fd, size_t size, struct _pie_load_info *li, Elf32_Ehdr *hdr
+) {
 	int res;
 	Elf32_Shdr shdr;
 	Elf32_Rel rel;
@@ -447,7 +447,7 @@ _run_relocations(int fd, int size, struct _pie_load_info *li, Elf32_Ehdr *hdr)
 			return res;
 		}
 
-		for (int j = 0; j < reloc_count; j++) {
+		for (uint32_t j = 0; j < reloc_count; j++) {
 			if ((res = epic_file_read(
 				     fd, &rel, sizeof(Elf32_Rel))) !=
 			    sizeof(Elf32_Rel)) {
@@ -464,7 +464,7 @@ _run_relocations(int fd, int size, struct _pie_load_info *li, Elf32_Ehdr *hdr)
 			// (ie., do not resolve relocation - they default to a safe NULL)
 			uint8_t skip = 0;
 			if (sym != 0) {
-				for (int k = 0; k < li->weak_symbol_count;
+				for (uint32_t k = 0; k < li->weak_symbol_count;
 				     k++) {
 					if (li->weak_symbols[k] == sym) {
 						skip = 1;
@@ -513,7 +513,7 @@ _run_relocations(int fd, int size, struct _pie_load_info *li, Elf32_Ehdr *hdr)
  * Load a l0dable PIE binary.
  */
 static int
-_load_pie(int fd, int size, Elf32_Ehdr *hdr, struct l0dable_info *info)
+_load_pie(int fd, size_t size, Elf32_Ehdr *hdr, struct l0dable_info *info)
 {
 	int res;
 	struct _pie_load_info li = { 0 };
@@ -545,7 +545,8 @@ _load_pie(int fd, int size, Elf32_Ehdr *hdr, struct l0dable_info *info)
 
 		if (phdr.p_type == PT_LOAD) {
 			// Check alignment request.
-			if ((phdr.p_vaddr % phdr.p_align) != 0) {
+			if ((phdr.p_offset % phdr.p_align) !=
+			    (phdr.p_vaddr % phdr.p_align)) {
 				LOG_ERR("l0der",
 					"_load_pie: phdr %d alignment too strict",
 					i);
@@ -646,7 +647,10 @@ int l0der_load_path(const char *path, struct l0dable_info *info)
 		return res;
 	}
 
-	int size = epic_file_tell(fd);
+	if ((res = epic_file_tell(fd)) < 0) {
+		return res;
+	}
+	size_t size = res;
 
 	if ((res = epic_file_seek(fd, 0, SEEK_SET)) != 0) {
 		return res;

epicardium/main.c

 #include "modules/modules.h"
-#include "modules/log.h"
-#include "modules/filesystem.h"
+#include "os/core.h"
+#include "os/work_queue.h"
+#include "fs/filesystem.h"
+#include "drivers/drivers.h"
+#include "user_core/user_core.h"
+#include "os/config.h"
 #include "card10-version.h"
+#include "user_core/interrupts.h"
+#include "drivers/display/epic_ctx.h"
+
+#include "leds.h"
+#include "version-splash.h"
 
 #include "FreeRTOS.h"
 #include "task.h"
@@ -9,6 +18,9 @@
 
 #include <stdlib.h>
 #include <string.h>
+#include <machine/endian.h>
+
+#include "epic_boot.c"
 
 int main(void)
 {
@@ -20,16 +32,75 @@ int main(void)
 	LOG_DEBUG("startup", "Initializing hardware ...");
 	hardware_early_init();
 
-	/*
-	 * Version Splash
-	 */
-	const char *version_buf = CARD10_VERSION;
-	const int offset = (160 - (int)strlen(version_buf) * 14) / 2;
-	epic_disp_clear(0x3b7);
-	epic_disp_print(10, 20, "Epicardium", 0x290, 0x3b7);
-	epic_disp_print(offset > 0 ? offset : 0, 40, version_buf, 0x290, 0x3b7);
+	load_config();
+
+	migration_delete_app_launchers();
+
+	//LED feedback in case of dead display
+	epic_leds_set(11, 0, 0, 1);
+	epic_leds_set(12, 0, 0, 1);
+	epic_leds_set(13, 0, 0, 1);
+	epic_leds_set(14, 0, 0, 1);
+
+	epic_disp_clear(0x0000);
+
+#if 0 /* reenable for future releases */
+	epic_leds_set_rocket(0, 31);
+	epic_leds_set_rocket(1, 31);
+	epic_leds_set_rocket(2, 31);
+
+	// TODO: Use blit function here
+#if BYTE_ORDER == LITTLE_ENDIAN
+	for (size_t i = 0; i < sizeof(epicardium_ctx_fb); i += 2) {
+		epicardium_ctx_fb[i]     = version_splash[i + 1];
+		epicardium_ctx_fb[i + 1] = version_splash[i];
+	}
+#else
+	memcpy(epicardium_ctx_fb, version_splash, sizeof(epicardium_ctx_fb));
+#endif
+
+	if (strcmp(CARD10_VERSION, "v1.17") != 0) {
+		ctx_font_size(epicardium_ctx, 20.0f);
+		ctx_text_baseline(epicardium_ctx, CTX_TEXT_BASELINE_BOTTOM);
+		ctx_rgba8(epicardium_ctx, 0xff, 0xc6, 0x00, 0xff);
+
+		ctx_text_align(epicardium_ctx, CTX_TEXT_ALIGN_CENTER);
+		ctx_move_to(epicardium_ctx, 80.0f, 58.0f);
+		ctx_text(epicardium_ctx, "Epicardium");
+
+		ctx_text_align(epicardium_ctx, CTX_TEXT_ALIGN_LEFT);
+		ctx_move_to(epicardium_ctx, 2.0f, 78.0f);
+		ctx_text(epicardium_ctx, CARD10_VERSION);
+
+		/* re-init for the first app */
+		disp_ctx_reinit();
+	}
 	epic_disp_update();
 	mxc_delay(2000000);
+#else
+	for (uint32_t frame = 0; frame < 15; frame++) {
+		switch (frame) {
+		case 0:
+			epic_leds_set_rocket(0, 31);
+			break;
+		case 5:
+			epic_leds_set_rocket(1, 31);
+			break;
+		case 10:
+			epic_leds_set_rocket(2, 31);
+			break;
+		}
+
+		epic_disp_clear(0x0000);
+		epic_frame(epicardium_ctx, frame);
+		epic_disp_update();
+	}
+
+	/* re-init for the first app */
+	disp_ctx_reinit();
+#endif
+
+	epic_leds_clear_all(0, 0, 0);
 
 	LOG_DEBUG("startup", "Initializing tasks ...");
 
@@ -39,22 +110,20 @@ int main(void)
 		    (const char *)"Serial",
 		    configMINIMAL_STACK_SIZE * 2,
 		    NULL,
-		    tskIDLE_PRIORITY + 1,
+		    tskIDLE_PRIORITY + 3,
 		    NULL) != pdPASS) {
-		LOG_CRIT("startup", "Failed to create %s task!", "Serial");
-		abort();
+		panic("Failed to create %s task!", "Serial");
 	}
 
 	/* PMIC */
 	if (xTaskCreate(
 		    vPmicTask,
 		    (const char *)"PMIC",
-		    configMINIMAL_STACK_SIZE,
+		    configMINIMAL_STACK_SIZE * 3,
 		    NULL,
 		    tskIDLE_PRIORITY + 4,
 		    NULL) != pdPASS) {
-		LOG_CRIT("startup", "Failed to create %s task!", "PMIC");
-		abort();
+		panic("Failed to create %s task!", "PMIC");
 	}
 
 	/* BHI160 */
@@ -65,8 +134,7 @@ int main(void)
 		    NULL,
 		    tskIDLE_PRIORITY + 1,
 		    NULL) != pdPASS) {
-		LOG_CRIT("startup", "Failed to create %s task!", "BHI160");
-		abort();
+		panic("Failed to create %s task!", "BHI160");
 	}
 
 	/* MAX30001 */
@@ -77,9 +145,36 @@ int main(void)
 		    NULL,
 		    tskIDLE_PRIORITY + 1,
 		    NULL) != pdPASS) {
-		LOG_CRIT("startup", "Failed to create %s task!", "MAX30001");
+		panic("Failed to create %s task!", "MAX30001");
+	}
+
+	/* MAX86150 */
+	if (xTaskCreate(
+		    vMAX86150Task,
+		    (const char *)"MAX86150 Driver",
+		    configMINIMAL_STACK_SIZE * 2,
+		    NULL,
+		    tskIDLE_PRIORITY + 1,
+		    NULL) != pdPASS) {
+		panic("Failed to create %s task!", "MAX86150");
+	}
+
+	/* BSEC */
+	if (bsec_activate() == 0) {
+		if (xTaskCreate(
+			    vBSECTask,
+			    (const char *)"BSEC",
+			    configMINIMAL_STACK_SIZE * 5,
+			    NULL,
+			    tskIDLE_PRIORITY + 1,
+			    NULL) != pdPASS) {
+			LOG_CRIT(
+				"startup", "Failed to create %s task!", "BSEC"
+			);
 			abort();
 		}
+	}
+
 	/* API */
 	if (xTaskCreate(
 		    vApiDispatcher,
@@ -88,55 +183,62 @@ int main(void)
 		    NULL,
 		    tskIDLE_PRIORITY + 2,
 		    &dispatcher_task_id) != pdPASS) {
-		LOG_CRIT(
-			"startup",
-			"Failed to create %s task!",
-			"API Dispatcher"
-		);
-		abort();
+		panic("Failed to create %s task!", "API Dispatcher");
+	}
+	/* Interrupts */
+	if (xTaskCreate(
+		    vInterruptsTask,
+		    (const char *)"Interrupt Dispatcher",
+		    configMINIMAL_STACK_SIZE,
+		    NULL,
+		    tskIDLE_PRIORITY + 2,
+		    NULL) != pdPASS) {
+		panic("Failed to create %s task!", "Interrupt Dispatcher");
 	}
 
 	/* BLE */
-	if (ble_shall_start()) {
+	if (ble_is_enabled()) {
 		if (xTaskCreate(
 			    vBleTask,
 			    (const char *)"BLE",
 			    configMINIMAL_STACK_SIZE * 10,
 			    NULL,
-			    tskIDLE_PRIORITY + 1,
+			    tskIDLE_PRIORITY + 3,
 			    NULL) != pdPASS) {
-			LOG_CRIT("startup", "Failed to create %s task!", "BLE");
-			abort();
+			panic("Failed to create %s task!", "BLE");
 		}
 	}
 
-	/* LEDs */
+	/* Lifecycle */
 	if (xTaskCreate(
-		    vLedTask,
-		    (const char *)"LED",
-		    configMINIMAL_STACK_SIZE,
+		    vLifecycleTask,
+		    (const char *)"Lifecycle",
+		    configMINIMAL_STACK_SIZE * 4,
 		    NULL,
-		    tskIDLE_PRIORITY + 1,
+		    tskIDLE_PRIORITY + 3,
 		    NULL) != pdPASS) {
-		LOG_CRIT("startup", "Failed to create %s task!", "LED");
-		abort();
+		panic("Failed to create %s task!", "Lifecycle");
 	}
 
-	/* Lifecycle */
+	/* Work Queue */
 	if (xTaskCreate(
-		    vLifecycleTask,
-		    (const char *)"Lifecycle",
+		    vWorkQueueTask,
+		    (const char *)"Work Queue",
 		    configMINIMAL_STACK_SIZE * 4,
 		    NULL,
-		    tskIDLE_PRIORITY + 3,
+		    tskIDLE_PRIORITY + 1,
 		    NULL) != pdPASS) {
-		LOG_CRIT("startup", "Failed to create %s task!", "Lifecycle");
-		abort();
+		panic("Failed to create %s task!", "Work Queue");
 	}
+	workqueue_init();
+
+	/*
+	 * Initialize serial driver data structures.
+	 */
+	serial_init();
 
 	LOG_DEBUG("startup", "Starting FreeRTOS ...");
 	vTaskStartScheduler();
 
-	LOG_CRIT("startup", "FreeRTOS did not start due to unknown error!");
-	abort();
+	panic("FreeRTOS did not start due to unknown error!");
 }

epicardium/meson.build

@@ -66,29 +66,50 @@ freertos = static_library(
 ##########################################################################
 
 subdir('modules/')
+subdir('drivers/')
+subdir('user_core/')
 subdir('ble/')
+subdir('os/')
+subdir('fs/')
 
 subdir('l0der/')
 
-epicardium_cargs = []
+epicardium_cargs = ['-D_POSIX_C_SOURCE=200809']
 if get_option('jailbreak_card10')
   epicardium_cargs += [
     '-DJAILBREAK_CARD10=1',
   ]
 endif
 
+version_screen = custom_target(
+  'version-splash.h',
+  input: 'version-splash.png',
+  output: 'version-splash.h',
+  command: [
+    python3,
+    meson.current_source_dir() + '../tools/version-image.py',
+    '@INPUT@',
+    '@OUTPUT@',
+  ],
+)
 
 elf = executable(
   name + '.elf',
-  'cdcacm.c',
+  'usb/epc_usb.c',
+  'usb/cdcacm.c',
+  'usb/mass_storage.c',
   'main.c',
   'support.c',
-  'fs/filesystem_fat.c',
   module_sources,
+  os_sources,
+  user_core_sources,
+  driver_sources,
+  fs_sources,
   l0der_sources,
   ble_sources,
   version_hdr,
-  dependencies: [libcard10, max32665_startup_core0, maxusb, libff13, ble, bhy1],
+  version_screen,
+  dependencies: [libcard10, max32665_startup_core0, maxusb, libff13, ble, bhy1, libcrypto, bsec, libctx],
   link_with: [api_dispatcher_lib, freertos],
   link_whole: [max32665_startup_core0_lib, board_card10_lib, newlib_heap_lib],
   include_directories: [freertos_includes],

epicardium/modules/bhi.c

-#include <stdio.h>
-#include <string.h>
-
-#include "gpio.h"
-#include "bhy_uc_driver.h"
-#include "bhy.h"
-#include "pmic.h"
-
-#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 "modules/modules.h"
-#include "modules/stream.h"
-
-/* Ticks to wait when trying to acquire lock */
-#define LOCK_WAIT pdMS_TO_TICKS(BHI160_MUTEX_WAIT_MS)
-
-/* BHI160 Firmware Blob.  Contents are defined in libcard10. */
-extern uint8_t bhy1_fw[];
-
-/* Interrupt Pin */
-static const gpio_cfg_t bhi160_interrupt_pin = {
-	PORT_0, PIN_13, GPIO_FUNC_IN, GPIO_PAD_PULL_UP
-};
-
-/* Axis remapping matrices */
-static int8_t bhi160_mapping_matrix[3 * 3] = { 0, -1, 0, 1, 0, 0, 0, 0, 1 };
-static int8_t bmm150_mapping_matrix[3 * 3] = { -1, 0, 0, 0, 1, 0, 0, 0, -1 };
-
-/*
- * From the official docs:
- *
- *    The sic matrix should be calculated for customer platform by logging
- *    uncalibrated magnetometer data.  The sic matrix here is only an example
- *    array (identity matrix). Customer should generate their own matrix.  This
- *    affects magnetometer fusion performance.
- *
- * TODO: Get data for card10
- */
-/* clang-format off */
-static float bhi160_sic_array[3 * 3] = { 1.0, 0.0, 0.0,
-                                         0.0, 1.0, 0.0,
-                                         0.0, 0.0, 1.0 };
-/* clang-format on */
-
-/* BHI160 Fifo */
-static uint8_t bhi160_fifo[BHI160_FIFO_SIZE];
-static size_t start_index = 0;
-
-/* BHI160 Task ID */
-static TaskHandle_t bhi160_task_id = NULL;
-
-/* BHI160 Mutex */
-static StaticSemaphore_t bhi160_mutex_data;
-static SemaphoreHandle_t bhi160_mutex = NULL;
-
-/* Streams */
-static struct stream_info bhi160_streams[10];
-
-/* Active */
-static bool bhi160_sensor_active[10] = { 0 };
-
-/* -- Utilities -------------------------------------------------------- {{{ */
-/*
- * Retrieve the data size for a sensor.  This value is needed for the creation
- * of the sensor's sample queue.
- */
-static size_t bhi160_lookup_data_size(enum bhi160_sensor_type type)
-{
-	switch (type) {
-	case BHI160_ACCELEROMETER:
-	case BHI160_MAGNETOMETER:
-	case BHI160_ORIENTATION:
-	case BHI160_GYROSCOPE:
-		return sizeof(struct bhi160_data_vector);
-	default:
-		return 0;
-	}
-}
-
-/*
- * Map a sensor type to the virtual sensor ID used by BHy1.
- */
-static bhy_virtual_sensor_t bhi160_lookup_vs_id(enum bhi160_sensor_type type)
-{
-	switch (type) {
-	case BHI160_ACCELEROMETER:
-		return VS_ID_ACCELEROMETER;
-	case BHI160_ORIENTATION:
-		return VS_ID_ORIENTATION;
-	case BHI160_GYROSCOPE:
-		return VS_ID_GYROSCOPE;
-	default:
-		return -1;
-	}
-}
-
-/*
- * Map a sensor type to its stream descriptor.
- */
-static int bhi160_lookup_sd(enum bhi160_sensor_type type)
-{
-	switch (type) {
-	case BHI160_ACCELEROMETER:
-		return SD_BHI160_ACCELEROMETER;
-	case BHI160_ORIENTATION:
-		return SD_BHI160_ORIENTATION;
-	case BHI160_GYROSCOPE:
-		return SD_BHI160_GYROSCOPE;
-	default:
-		return -1;
-	}
-}
-/* }}} */
-
-/* -- API -------------------------------------------------------------- {{{ */
-int epic_bhi160_enable_sensor(
-	enum bhi160_sensor_type sensor_type,
-	struct bhi160_sensor_config *config
-) {
-	int result = 0;
-
-	bhy_virtual_sensor_t vs_id = bhi160_lookup_vs_id(sensor_type);
-	if (vs_id < 0) {
-		return -ENODEV;
-	}
-
-	result = hwlock_acquire(HWLOCK_I2C, pdMS_TO_TICKS(100));
-	if (result < 0) {
-		return result;
-	}
-
-	if (xSemaphoreTake(bhi160_mutex, LOCK_WAIT) != pdTRUE) {
-		result = -EBUSY;
-		goto out_free_i2c;
-	}
-
-	struct stream_info *stream = &bhi160_streams[sensor_type];
-	stream->item_size          = bhi160_lookup_data_size(sensor_type);
-	/* TODO: Sanity check length */
-	stream->queue =
-		xQueueCreate(config->sample_buffer_len, stream->item_size);
-	if (stream->queue == NULL) {
-		result = -ENOMEM;
-		goto out_free_both;
-	}
-
-	result = stream_register(bhi160_lookup_sd(sensor_type), stream);
-	if (result < 0) {
-		goto out_free_both;
-	}
-
-	result = bhy_enable_virtual_sensor(
-		vs_id,
-		VS_WAKEUP,
-		config->sample_rate,
-		0,
-		VS_FLUSH_NONE,
-		0,
-		config->dynamic_range /* dynamic range is sensor dependent */
-	);
-	if (result != BHY_SUCCESS) {
-		goto out_free_both;
-	}
-
-	bhi160_sensor_active[sensor_type] = true;
-	result                            = bhi160_lookup_sd(sensor_type);
-
-out_free_both:
-	xSemaphoreGive(bhi160_mutex);
-out_free_i2c:
-	hwlock_release(HWLOCK_I2C);
-	return result;
-}
-
-int epic_bhi160_disable_sensor(enum bhi160_sensor_type sensor_type)
-{
-	int result = 0;
-
-	bhy_virtual_sensor_t vs_id = bhi160_lookup_vs_id(sensor_type);
-	if (vs_id < 0) {
-		return -ENODEV;
-	}
-
-	result = hwlock_acquire(HWLOCK_I2C, pdMS_TO_TICKS(100));
-	if (result < 0) {
-		return result;
-	}
-
-	if (xSemaphoreTake(bhi160_mutex, LOCK_WAIT) != pdTRUE) {
-		result = -EBUSY;
-		goto out_free_i2c;
-	}
-
-	struct stream_info *stream = &bhi160_streams[sensor_type];
-	result = stream_deregister(bhi160_lookup_sd(sensor_type), stream);
-	if (result < 0) {
-		goto out_free_both;
-	}
-
-	vQueueDelete(stream->queue);
-	stream->queue = NULL;
-	result        = bhy_disable_virtual_sensor(vs_id, VS_WAKEUP);
-	if (result < 0) {
-		goto out_free_both;
-	}
-
-	bhi160_sensor_active[sensor_type] = false;
-
-	result = 0;
-out_free_both:
-	xSemaphoreGive(bhi160_mutex);
-out_free_i2c:
-	hwlock_release(HWLOCK_I2C);
-	return result;
-}
-
-void epic_bhi160_disable_all_sensors()
-{
-	for (int i = 0; i < sizeof(bhi160_sensor_active); i++) {
-		if (bhi160_sensor_active[i]) {
-			epic_bhi160_disable_sensor(i);
-		}
-	}
-}
-
-/* }}} */
-
-/* -- Driver ----------------------------------------------------------- {{{ */
-/*
- * Handle a single packet from the FIFO.  For most sensors this means pushing
- * the sample into its sample queue.
- */
-static void
-bhi160_handle_packet(bhy_data_type_t data_type, bhy_data_generic_t *sensor_data)
-{
-	uint8_t sensor_id = sensor_data->data_vector.sensor_id;
-	struct bhi160_data_vector data_vector;
-	/*
-	 * Timestamp of the next samples, counting at 32 kHz.
-	 * Currently unused.
-	 */
-	static uint32_t timestamp           = 0;
-	enum bhi160_sensor_type sensor_type = 0;
-	int epic_int                        = 0;
-	bool wakeup                         = false;
-
-	switch (sensor_id) {
-	case VS_ID_TIMESTAMP_MSW_WAKEUP:
-		wakeup = true;
-		/* fall through */
-	case VS_ID_TIMESTAMP_MSW:
-		MXC_ASSERT(data_type == BHY_DATA_TYPE_SCALAR_U16);
-		timestamp = sensor_data->data_scalar_u16.data << 16;
-		break;
-	case VS_ID_TIMESTAMP_LSW_WAKEUP:
-		wakeup = true;
-		/* fall through */
-	case VS_ID_TIMESTAMP_LSW:
-		MXC_ASSERT(data_type == BHY_DATA_TYPE_SCALAR_U16);
-		timestamp = (timestamp & 0xFFFF0000) |
-			    sensor_data->data_scalar_u16.data;
-		break;
-	case VS_ID_ACCELEROMETER_WAKEUP:
-	case VS_ID_ORIENTATION_WAKEUP:
-	case VS_ID_GYROSCOPE_WAKEUP:
-		wakeup = true;
-		/* fall through */
-	case VS_ID_ACCELEROMETER:
-	case VS_ID_ORIENTATION:
-	case VS_ID_GYROSCOPE:
-		switch (sensor_id) {
-		case VS_ID_ACCELEROMETER_WAKEUP:
-		case VS_ID_ACCELEROMETER:
-			sensor_type = BHI160_ACCELEROMETER;
-			epic_int    = EPIC_INT_BHI160_ACCELEROMETER;
-			break;
-		case VS_ID_ORIENTATION_WAKEUP:
-		case VS_ID_ORIENTATION:
-			sensor_type = BHI160_ORIENTATION;
-			epic_int    = EPIC_INT_BHI160_ORIENTATION;
-			break;
-		case VS_ID_GYROSCOPE_WAKEUP:
-		case VS_ID_GYROSCOPE:
-			sensor_type = BHI160_GYROSCOPE;
-			epic_int    = EPIC_INT_BHI160_GYROSCOPE;
-			break;
-		}
-
-		MXC_ASSERT(data_type == BHY_DATA_TYPE_VECTOR);
-		if (bhi160_streams[sensor_type].queue == NULL) {
-			break;
-		}
-		data_vector.data_type = BHI160_DATA_TYPE_VECTOR;
-		data_vector.x         = sensor_data->data_vector.x;
-		data_vector.y         = sensor_data->data_vector.y;
-		data_vector.z         = sensor_data->data_vector.z;
-		data_vector.status    = sensor_data->data_vector.status;
-		xQueueSend(
-			bhi160_streams[sensor_type].queue,
-			&data_vector,
-			BHI160_MUTEX_WAIT_MS
-		);
-		if (wakeup) {
-			api_interrupt_trigger(epic_int);
-		}
-		break;
-	default:
-		break;
-	}
-}
-
-/*
- * Fetch all data available from BHI160's FIFO buffer and handle all packets
- * contained in it.
- */
-static int bhi160_fetch_fifo(void)
-{
-	/*
-	 * Warning:  The code from the BHy1 docs has some issues.  This
-	 * implementation looks similar, but has a few important differences.
-	 * You'll probably be best of leaving it as it is ...
-	 */
-
-	int result = 0;
-	/* Number of bytes left in BHI160's FIFO buffer */
-	uint16_t bytes_left_in_fifo = 1;
-
-	result = hwlock_acquire(HWLOCK_I2C, pdMS_TO_TICKS(100));
-	if (result < 0) {
-		return result;
-	}
-
-	if (xSemaphoreTake(bhi160_mutex, LOCK_WAIT) != pdTRUE) {
-		result = -EBUSY;
-		goto out_free_i2c;
-	}
-
-	while (bytes_left_in_fifo) {
-		/* Fill local FIFO buffer with as many bytes as possible */
-		uint16_t bytes_read;
-		bhy_read_fifo(
-			&bhi160_fifo[start_index],
-			BHI160_FIFO_SIZE - start_index,
-			&bytes_read,
-			&bytes_left_in_fifo
-		);
-
-		/* Add the bytes left from the last transfer on top */
-		bytes_read += start_index;
-
-		/* Handle all full packets received in this transfer */
-		uint8_t *fifo_ptr   = bhi160_fifo;
-		uint16_t bytes_left = bytes_read;
-		while (bytes_left > 0) {
-			bhy_data_generic_t sensor_data;
-			bhy_data_type_t data_type;
-			result = bhy_parse_next_fifo_packet(
-				&fifo_ptr,
-				&bytes_left,
-				&sensor_data,
-				&data_type
-			);
-
-			if (result == BHY_SUCCESS) {
-				bhi160_handle_packet(data_type, &sensor_data);
-			} else {
-				break;
-			}
-		}
-
-		/* Shift the remaining bytes to the beginning */
-		for (int i = 0; i < bytes_left; i++) {
-			bhi160_fifo[i] =
-				bhi160_fifo[bytes_read - bytes_left + i];
-		}
-		start_index = bytes_left;
-	}
-
-	xSemaphoreGive(bhi160_mutex);
-out_free_i2c:
-	hwlock_release(HWLOCK_I2C);
-	return result;
-}
-
-/*
- * Callback for the BHI160 interrupt pin.  This callback is called from the
- * SDK's GPIO interrupt driver, in interrupt context.
- */
-static void bhi160_interrupt_callback(void *_)
-{
-	BaseType_t xHigherPriorityTaskWoken = pdFALSE;
-
-	if (bhi160_task_id != NULL) {
-		vTaskNotifyGiveFromISR(
-			bhi160_task_id, &xHigherPriorityTaskWoken
-		);
-		portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
-	}
-}
-/* }}} */
-
-void vBhi160Task(void *pvParameters)
-{
-	int ret;
-
-	bhi160_task_id = xTaskGetCurrentTaskHandle();
-	bhi160_mutex   = xSemaphoreCreateMutexStatic(&bhi160_mutex_data);
-
-	/*
-	 * Wait a little before initializing BHI160.
-	 */
-	vTaskDelay(pdMS_TO_TICKS(3));
-
-	int lockret = hwlock_acquire(HWLOCK_I2C, pdMS_TO_TICKS(100));
-	if (lockret < 0) {
-		LOG_CRIT("bhi160", "Failed to acquire I2C lock!");
-		vTaskDelay(portMAX_DELAY);
-	}
-
-	/* Take Mutex during initialization, just in case */
-	if (xSemaphoreTake(bhi160_mutex, 0) != pdTRUE) {
-		LOG_CRIT("bhi160", "Failed to acquire BHI160 mutex!");
-		vTaskDelay(portMAX_DELAY);
-	}
-
-	memset(bhi160_streams, 0x00, sizeof(bhi160_streams));
-
-	/* Install interrupt callback */
-	GPIO_Config(&bhi160_interrupt_pin);
-	GPIO_RegisterCallback(
-		&bhi160_interrupt_pin, bhi160_interrupt_callback, NULL
-	);
-	GPIO_IntConfig(&bhi160_interrupt_pin, GPIO_INT_EDGE, GPIO_INT_RISING);
-	GPIO_IntEnable(&bhi160_interrupt_pin);
-	NVIC_SetPriority(
-		(IRQn_Type)MXC_GPIO_GET_IRQ(bhi160_interrupt_pin.port), 2
-	);
-	NVIC_EnableIRQ((IRQn_Type)MXC_GPIO_GET_IRQ(bhi160_interrupt_pin.port));
-
-	/* Upload firmware */
-	ret = bhy_driver_init(bhy1_fw);
-	if (ret) {
-		LOG_CRIT("bhi160", "BHy1 init failed!");
-		vTaskDelay(portMAX_DELAY);
-	}
-
-	/* Wait for first interrupt */
-	hwlock_release(HWLOCK_I2C);
-	ulTaskNotifyTake(pdTRUE, pdMS_TO_TICKS(100));
-	lockret = hwlock_acquire(HWLOCK_I2C, pdMS_TO_TICKS(100));
-	if (lockret < 0) {
-		LOG_CRIT("bhi160", "Failed to acquire I2C lock!");
-		vTaskDelay(portMAX_DELAY);
-	}
-
-	/* Remap axes to match card10 layout */
-	bhy_mapping_matrix_set(
-		PHYSICAL_SENSOR_INDEX_ACC, bhi160_mapping_matrix
-	);
-	bhy_mapping_matrix_set(
-		PHYSICAL_SENSOR_INDEX_MAG, bmm150_mapping_matrix
-	);
-	bhy_mapping_matrix_set(
-		PHYSICAL_SENSOR_INDEX_GYRO, bhi160_mapping_matrix
-	);
-
-	/* Set "SIC" matrix.  TODO: Find out what this is about */
-	bhy_set_sic_matrix(bhi160_sic_array);
-
-	xSemaphoreGive(bhi160_mutex);
-	hwlock_release(HWLOCK_I2C);
-
-	/* ----------------------------------------- */
-
-	while (1) {
-		int ret = bhi160_fetch_fifo();
-		if (ret == -EBUSY) {
-			LOG_WARN("bhi160", "Could not acquire mutex for FIFO?");
-			continue;
-		} else if (ret < 0) {
-			LOG_ERR("bhi160", "Unknown error: %d", -ret);
-		}
-
-		/*
-		 * Wait for interrupt.  After two seconds, fetch FIFO anyway in
-		 * case there are any diagnostics or errors.
-		 *
-		 * 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/modules/bme680.c

-#include "epicardium.h"
-#include "modules/modules.h"
-#include "modules/log.h"
-
-#include "card10.h"
-
-#include "bme680.h"
-#include "bosch.h"
-
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdio.h>
-
-#define HEATR_TEMP 320
-#define HEATR_DUR 150
-
-static bool initialized;
-static struct bme680_dev bme;
-
-static int convert_error(int8_t error)
-{
-	switch (error) {
-	case BME680_OK:
-		return 0;
-	case BME680_E_NULL_PTR:
-		return EFAULT;
-	case BME680_E_COM_FAIL:
-		return EIO;
-	case BME680_E_DEV_NOT_FOUND:
-		return ENODEV;
-	case BME680_E_INVALID_LENGTH:
-		return EINVAL;
-	default:
-		return 1;
-	}
-}
-
-int epic_bme680_init()
-{
-	int8_t result = BME680_OK;
-
-	if (initialized) {
-		return 0;
-	}
-
-	if (hwlock_acquire(HWLOCK_I2C, pdMS_TO_TICKS(100)) < 0) {
-		return -EBUSY;
-	}
-
-	bme.dev_id   = BME680_I2C_ADDR_PRIMARY;
-	bme.intf     = BME680_I2C_INTF;
-	bme.read     = card10_bosch_i2c_read;
-	bme.write    = card10_bosch_i2c_write;
-	bme.delay_ms = card10_bosch_delay;
-
-	/*
-	 * amb_temp can be set to 25 prior to configuring the gas sensor
-	 * or by performing a few temperature readings without operating
-	 * the gas sensor.
-	 */
-	bme.amb_temp = 25;
-
-	result = bme680_init(&bme);
-	if (result != BME680_OK) {
-		LOG_ERR("bme680", "bme680_init error: %d\n", result);
-		goto err;
-	}
-
-	/*
-	 * Select the power mode.  Must be set before writing the sensor
-	 * configuration
-	 */
-	bme.power_mode = BME680_FORCED_MODE;
-
-	/* Set the temperature, pressure and humidity settings */
-	bme.tph_sett.os_hum  = BME680_OS_2X;
-	bme.tph_sett.os_pres = BME680_OS_4X;
-	bme.tph_sett.os_temp = BME680_OS_8X;
-	bme.tph_sett.filter  = BME680_FILTER_SIZE_3;
-
-	/* Set the remaining gas sensor settings and link the heating profile */
-	bme.gas_sett.run_gas = BME680_ENABLE_GAS_MEAS;
-	/* Create a ramp heat waveform in 3 steps */
-	bme.gas_sett.heatr_temp = HEATR_TEMP; /* degree Celsius */
-	bme.gas_sett.heatr_dur  = HEATR_DUR;  /* milliseconds */
-
-	/* Set the required sensor settings needed */
-	uint16_t settings_sel = BME680_OST_SEL | BME680_OSP_SEL |
-				BME680_OSH_SEL | BME680_FILTER_SEL |
-				BME680_GAS_SENSOR_SEL;
-
-	result = bme680_set_sensor_settings(settings_sel, &bme);
-	if (result != BME680_OK) {
-		LOG_ERR("bme680",
-			"bme680_set_sensor_settings error: %d\n",
-			result);
-		goto err;
-	}
-
-	initialized = true;
-	result      = BME680_OK;
-err:
-	hwlock_release(HWLOCK_I2C);
-	return -convert_error(result);
-}
-
-int epic_bme680_deinit()
-{
-	if (!initialized) {
-		return 0;
-	}
-
-	if (hwlock_acquire(HWLOCK_I2C, pdMS_TO_TICKS(100)) < 0) {
-		return -EBUSY;
-	}
-
-	int8_t result = bme680_soft_reset(&bme);
-	if (result != BME680_OK) {
-		LOG_ERR("bme680", "bme680_soft_reset error: %d\n", result);
-	}
-
-	hwlock_release(HWLOCK_I2C);
-	initialized = false;
-	return 0;
-}
-
-int epic_bme680_read_sensors(struct bme680_sensor_data *data)
-{
-	int8_t result = BME680_OK;
-
-	if (!initialized) {
-		LOG_ERR("bme680", "bme680 sensor not initialized");
-		return -EINVAL;
-	}
-
-	if (hwlock_acquire(HWLOCK_I2C, pdMS_TO_TICKS(100)) < 0) {
-		return -EBUSY;
-	}
-
-	uint16_t profile_dur = 0;
-	bme680_get_profile_dur(&profile_dur, &bme);
-
-	result = bme680_set_sensor_mode(&bme); /* Trigger a measurement */
-	if (result != BME680_OK) {
-		LOG_ERR("bme680", "bme680_set_sensor_mode error: %d\n", result);
-		goto err;
-	}
-
-	/*
-	 * Wait for the measurement to complete.  Release the I2C lock in the
-	 * meantime.
-	 */
-	hwlock_release(HWLOCK_I2C);
-	vTaskDelay(pdMS_TO_TICKS(profile_dur));
-	if (hwlock_acquire(HWLOCK_I2C, pdMS_TO_TICKS(100)) < 0) {
-		return -EBUSY;
-	}
-
-	struct bme680_field_data raw_data;
-	result = bme680_get_sensor_data(&raw_data, &bme);
-	if (result != BME680_OK) {
-		LOG_ERR("bme680", "bme680_get_sensor_data error: %d\n", result);
-		goto err;
-	}
-
-	data->temperature    = (float)raw_data.temperature / 100.0f;
-	data->humidity       = raw_data.humidity / 1000.0f;
-	data->pressure       = raw_data.pressure / 100.0f;
-	data->gas_resistance = raw_data.gas_resistance;
-
-	result = BME680_OK;
-err:
-	hwlock_release(HWLOCK_I2C);
-	return -convert_error(result);
-}

epicardium/modules/dispatcher.c

-#include "modules/log.h"
-
-#include "api/dispatcher.h"
-
-#include "FreeRTOS.h"
-#include "task.h"
-#include "semphr.h"
-
-#define TIMEOUT pdMS_TO_TICKS(2000)
-
-TaskHandle_t dispatcher_task_id;
-
-static StaticSemaphore_t api_mutex_data;
-SemaphoreHandle_t api_mutex = NULL;
-
-/*
- * API dispatcher task.  This task will sleep until an API call is issued and
- * then wake up to dispatch it.
- */
-void vApiDispatcher(void *pvParameters)
-{
-	api_mutex = xSemaphoreCreateMutexStatic(&api_mutex_data);
-
-	LOG_DEBUG("dispatcher", "Ready.");
-	while (1) {
-		if (api_dispatcher_poll()) {
-			if (xSemaphoreTake(api_mutex, TIMEOUT) != pdTRUE) {
-				LOG_ERR("dispatcher", "API mutex blocked");
-				continue;
-			}
-			api_dispatcher_exec();
-			xSemaphoreGive(api_mutex);
-		}
-		ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
-	}
-}

epicardium/modules/display.c

-#include "display.h"
-#include "Fonts/fonts.h"
-#include "FreeRTOS.h"
-#include "LCD_Driver.h"
-#include "epicardium.h"
-#include "gfx.h"
-#include "gpio.h"
-#include "task.h"
-#include "tmr.h"
-#include "tmr_utils.h"
-
-static TaskHandle_t lock = NULL;
-
-static int check_lock()
-{
-	TaskHandle_t task = xTaskGetCurrentTaskHandle();
-	if (task != lock) {
-		return -EBUSY;
-	} else {
-		return 0;
-	}
-}
-
-int epic_disp_print(
-	uint16_t posx,
-	uint16_t posy,
-	const char *pString,
-	uint16_t fg,
-	uint16_t bg
-) {
-	int cl = check_lock();
-	if (cl < 0) {
-		return cl;
-	} else {
-		gfx_puts(&Font20, &display_screen, posx, posy, pString, fg, bg);
-		return 0;
-	}
-}
-
-int epic_disp_clear(uint16_t color)
-{
-	int cl = check_lock();
-	if (cl < 0) {
-		return cl;
-	} else {
-		gfx_clear_to_color(&display_screen, color);
-		return 0;
-	}
-}
-
-int epic_disp_pixel(uint16_t x, uint16_t y, uint16_t color)
-{
-	int cl = check_lock();
-	if (cl < 0) {
-		return cl;
-	} else {
-		gfx_setpixel(&display_screen, x, y, color);
-		return 0;
-	}
-}
-
-int epic_disp_line(
-	uint16_t xstart,
-	uint16_t ystart,
-	uint16_t xend,
-	uint16_t yend,
-	uint16_t color,
-	enum disp_linestyle linestyle,
-	uint16_t pixelsize
-) {
-	int cl = check_lock();
-	if (cl < 0) {
-		return cl;
-	} else {
-		/* TODO add linestyle support to gfx code */
-		gfx_line(
-			&display_screen,
-			xstart,
-			ystart,
-			xend,
-			yend,
-			pixelsize,
-			color
-		);
-		return 0;
-	}
-}
-
-int epic_disp_rect(
-	uint16_t xstart,
-	uint16_t ystart,
-	uint16_t xend,
-	uint16_t yend,
-	uint16_t color,
-	enum disp_fillstyle fillstyle,
-	uint16_t pixelsize
-) {
-	int cl = check_lock();
-	if (cl < 0)
-		return cl;
-
-	switch (fillstyle) {
-	case FILLSTYLE_EMPTY:
-		gfx_rectangle(
-			&display_screen,
-			xstart,
-			ystart,
-			xend - xstart,
-			yend - ystart,
-			pixelsize,
-			color
-		);
-		break;
-	case FILLSTYLE_FILLED:
-		gfx_rectangle_fill(
-			&display_screen,
-			xstart,
-			ystart,
-			xend - xstart,
-			yend - ystart,
-			color
-		);
-		break;
-	}
-	return 0;
-}
-
-int epic_disp_circ(
-	uint16_t x,
-	uint16_t y,
-	uint16_t rad,
-	uint16_t color,
-	enum disp_fillstyle fillstyle,
-	uint16_t pixelsize
-) {
-	int cl = check_lock();
-	if (cl < 0)
-		return cl;
-
-	switch (fillstyle) {
-	case FILLSTYLE_EMPTY:
-		gfx_circle(&display_screen, x, y, rad, pixelsize, color);
-		break;
-	case FILLSTYLE_FILLED:
-		gfx_circle_fill(&display_screen, x, y, rad, color);
-		break;
-	}
-
-	return 0;
-}
-
-int epic_disp_update()
-{
-	int cl = check_lock();
-	if (cl < 0) {
-		return cl;
-	}
-
-	gfx_update(&display_screen);
-	return 0;
-}
-
-int epic_disp_framebuffer(union disp_framebuffer *fb)
-{
-	int cl = check_lock();
-	if (cl < 0) {
-		return cl;
-	}
-
-	LCD_Set(fb->raw, sizeof(fb->raw));
-	return 0;
-}
-
-int epic_disp_backlight(uint16_t brightness)
-{
-	int cl = check_lock();
-	if (cl < 0) {
-		return cl;
-	}
-
-	LCD_SetBacklight(brightness);
-	return 0;
-}
-
-int epic_disp_open()
-{
-	TaskHandle_t task = xTaskGetCurrentTaskHandle();
-	if (lock == task) {
-		return 0;
-	} else if (lock == NULL) {
-		lock = task;
-		return 0;
-	} else {
-		return -EBUSY;
-	}
-}
-
-int epic_disp_close()
-{
-	if (check_lock() < 0 && lock != NULL) {
-		return -EBUSY;
-	} else {
-		lock = NULL;
-		return 0;
-	}
-}
-
-void disp_forcelock()
-{
-	TaskHandle_t task = xTaskGetCurrentTaskHandle();
-	lock              = task;
-}

epicardium/modules/gpio.c

-#include "epicardium.h"
-#include "gpio.h"
-#include "max32665.h"
-#include "mxc_errors.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)
- */
-static 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 },
-};
-
-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_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_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;
-	}
-
-	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;
-	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 {
-		return -EINVAL;
-	}
-}

epicardium/modules/hardware.c

 #include "epicardium.h"
 
 #include "api/dispatcher.h"
-#include "api/interrupt-sender.h"
-#include "cdcacm.h"
-#include "modules/filesystem.h"
-#include "modules/log.h"
+#include "usb/epc_usb.h"
+#include "fs/filesystem.h"
+#include "os/core.h"
 #include "modules/modules.h"
 #include "modules/stream.h"
+#include "drivers/drivers.h"
+#include "user_core/interrupts.h"
+#include "user_core/user_core.h"
 
 #include "card10.h"
-#include "display.h"
 #include "leds.h"
 #include "pb.h"
 #include "pmic.h"
 #include "portexpander.h"
+#include "max86150.h"
+#include "ble/ble_api.h"
 
 #include "gpio.h"
 #include "i2c.h"
 #include "rtc.h"
 #include "spi.h"
-#include "trng.h"
 #include "wdt.h"
 
 /*
@@ -54,6 +56,13 @@ int hardware_early_init(void)
 	 */
 	GPIO_Init();
 
+	/* Set the power hold pin, so the PMIC does not turn off again */
+	const gpio_cfg_t pwr_hold_pin = {
+		PORT_0, PIN_30, GPIO_FUNC_OUT, GPIO_PAD_NONE
+	};
+	GPIO_Config(&pwr_hold_pin);
+	GPIO_OutSet(&pwr_hold_pin);
+
 	/*
 	 * PMIC (MAX77650)
 	 */
@@ -67,40 +76,34 @@ int hardware_early_init(void)
 	 */
 	portexpander_init();
 
-	/*
-	 * RNG
-	 */
-	TRNG_Init(NULL);
-
 	/*
 	 * Buttons
 	 */
 	PB_Init();
 
 	/* Enable 32 kHz output */
-	while (RTC_SquareWave(
-		       MXC_RTC,
-		       SQUARE_WAVE_ENABLED,
-		       F_32KHZ,
-		       NOISE_IMMUNE_MODE,
-		       NULL) == E_BUSY
-	)
+	while (RTC_SquareWave(MXC_RTC, SQUARE_WAVE_ENABLED, F_32KHZ, NULL) ==
+	       E_BUSY)
 		;
 
+	/*
+	 * RNG
+	 */
+	rng_init();
+
 	/* If we don't have a valid time yet, set it to 2019-01-01 */
-	if (RTC_GetSecond() < 1546300800UL) {
+	if (RTC_GetSecond() < 1546300800L) {
 		epic_rtc_set_milliseconds(1546300800UL * 1000);
 	}
 
 	/*
 	 * SPI for ECG
 	 */
-	const sys_cfg_spi_t spi17y_master_cfg = {
-		.map = MAP_A,
+	const sys_cfg_spi_t spi17y_master_cfg = { .map    = MAP_A,
 						  .ss0    = Enable,
 						  .ss1    = Disable,
 						  .ss2    = Disable,
-	};
+						  .num_io = 2 };
 
 	if (SPI_Init(SPI0, 0, SPI_SPEED, spi17y_master_cfg) != 0) {
 		LOG_ERR("init", "Error configuring SPI");
@@ -109,10 +112,9 @@ int hardware_early_init(void)
 	}
 
 	/*
-	 * The bootloader has already initialized the display, so we only need
-	 * to do the bare minimum here (mostly the gfx datastructures).
+	 * Display
 	 */
-	display_init_slim();
+	disp_init();
 
 	/*
 	 * RGB LEDs
@@ -152,8 +154,8 @@ int hardware_early_init(void)
 	/*
 	 * USB-Serial
 	 */
-	if (cdcacm_init() < 0) {
-		LOG_ERR("init", "USB-Serial unavailable");
+	if (epic_usb_cdcacm() < 0) {
+		LOG_ERR("startup", "USB-Serial unavailable");
 	}
 
 	/*
@@ -164,7 +166,7 @@ int hardware_early_init(void)
 	/*
 	 * API Dispatcher & API Interrupts
 	 */
-	api_interrupt_init();
+	interrupt_init();
 	api_dispatcher_init();
 
 	/*
@@ -177,6 +179,31 @@ int hardware_early_init(void)
 	 */
 	hwlock_init();
 
+	/*
+	 * API Dispatcher Mutex
+	 */
+	dispatcher_mutex_init();
+
+	/*
+	 * MAX30001 mutex init
+	 */
+	max30001_mutex_init();
+
+	/*
+	 * max86150 mutex init
+	 */
+	max86150_mutex_init();
+
+	max86150_shut_down();
+
+	/*
+	 * BME680 Sensor
+	 */
+	epic_bme680_init();
+
+	/* Allow user space to trigger interrupts.
+	 * Used for BLE, not sure if needed. */
+	SCB->CCR |= SCB_CCR_USERSETMPEND_Msk;
 	return 0;
 }
 
@@ -212,7 +239,7 @@ int hardware_reset(void)
 	/*
 	 * API Dispatcher & API Interrupts
 	 */
-	api_interrupt_init();
+	interrupt_init();
 	api_dispatcher_init();
 
 	/*
@@ -243,19 +270,32 @@ int hardware_reset(void)
 	/*
 	 * Display
 	 */
-	display_init_slim();
+	disp_init();
+	epic_disp_backlight(20);
+
+	/*
+	 * Vibration Motor
+	 */
+	epic_vibra_set(false);
 
 	/*
 	 * BHI160
 	 */
 	epic_bhi160_disable_all_sensors();
 
+	epic_max30001_disable_sensor();
+
+	epic_max86150_disable_sensor();
+
 	/*
-	 * BME680 Sensor
+	 * BLE
 	 */
-	epic_bme680_deinit();
 
-	epic_max30001_disable_sensor();
+	/* Reset advertisement data */
+	ble_adv_setup();
+
+	/* Start advertising again if needed */
+	epic_ble_set_mode(false, false);
 
 	return 0;
 }

epicardium/modules/hw-lock.c

-#include "modules/log.h"
+#include "os/core.h"
 #include "modules/modules.h"
+#include "os/mutex.h"
 
 #include "FreeRTOS.h"
 #include "task.h"
-#include "semphr.h"
 
 #include <errno.h>
 
-static StaticSemaphore_t hwlock_mutex_data[_HWLOCK_MAX];
-static SemaphoreHandle_t hwlock_mutex[_HWLOCK_MAX];
-/* Which task is holding the lock */
-static TaskHandle_t hwlock_tasks[_HWLOCK_MAX];
+static struct mutex hwlock_mutex[_HWLOCK_MAX] = { { 0 } };
 
 void hwlock_init(void)
 {
 	for (int i = 0; i < _HWLOCK_MAX; i++) {
-		hwlock_mutex[i] =
-			xSemaphoreCreateMutexStatic(&hwlock_mutex_data[i]);
+		/*
+		 * TODO: mutex_create() names these all these mutexes
+		 *       "&hwlock_mutex[i]" which is not helpful at all.  We
+		 *       should somehow rename them to the actual hwlock names.
+		 */
+		mutex_create(&hwlock_mutex[i]);
 	}
 }
 
-int hwlock_acquire(enum hwlock_periph p, TickType_t wait)
+void hwlock_acquire(enum hwlock_periph p)
 {
-	if (p >= _HWLOCK_MAX) {
-		return -EINVAL;
+	assert(p < _HWLOCK_MAX);
+	mutex_lock(&hwlock_mutex[p]);
 }
-	TaskHandle_t task = xTaskGetCurrentTaskHandle();
 
-	if (xSemaphoreTake(hwlock_mutex[p], wait) != pdTRUE) {
-		/* Don't print warnings for 0 wait acquires */
-		if (wait == 0) {
-			return -EBUSY;
-		}
-
-		LOG_WARN(
-			"hwlock",
-			"Lock %u is busy! Held by \"%s\" and attempted to accquire by \"%s\"",
-			p,
-			pcTaskGetName(hwlock_tasks[p]),
-			pcTaskGetName(task)
-		);
-		LOG_DEBUG(
-			"hwlock",
-			"...attempted to lock from pc %p",
-			__builtin_return_address(0)
-		);
+int hwlock_acquire_nonblock(enum hwlock_periph p)
+{
+	assert(p < _HWLOCK_MAX);
+	if (mutex_trylock(&hwlock_mutex[p])) {
+		return 0;
+	} else {
 		return -EBUSY;
 	}
-
-	hwlock_tasks[p] = task;
-
-	return 0;
 }
 
-int hwlock_release(enum hwlock_periph p)
+void hwlock_release(enum hwlock_periph p)
 {
-	int ret = 0;
-
-	if (p >= _HWLOCK_MAX) {
-		return -EINVAL;
-	}
-
-	if (hwlock_tasks[p] != xTaskGetCurrentTaskHandle()) {
-		LOG_ERR("hwlock",
-			"Lock %u is released by task \"%s\" while it was acquired by \"%s\"",
-			p,
-			pcTaskGetName(NULL),
-			pcTaskGetName(hwlock_tasks[p]));
-		ret = -EACCES;
-	}
-
-	if (xSemaphoreGive(hwlock_mutex[p]) != pdTRUE) {
-		LOG_ERR("hwlock", "Lock %u not released correctly.", p);
-		ret = -EINVAL;
-	}
-
-	return ret;
+	assert(p < _HWLOCK_MAX);
+	mutex_unlock(&hwlock_mutex[p]);
 }