epicardium/api/control.c

@@ -199,11 +199,14 @@ void core1_boot(void)
 	core1_start(&core1_initial_ivt);
 }
 
-void core1_reset(void)
+void core1_trigger_reset(void)
 {
 	/* Signal core 1 that we intend to load a new payload. */
 	api_interrupt_trigger(EPIC_INT_RESET);
+}
 
+void core1_wait_ready(void)
+{
 	/* Wait for the core to accept */
 	while (1) {
 		while (SEMA_GetSema(_CONTROL_SEMAPHORE) == E_BUSY) {

epicardium/api/dispatcher.h

@@ -37,7 +37,10 @@ void api_prepare_args(char *args);
 void core1_boot(void);
 
 /* Reset core 1 into a state where it can accept a new payload */
-void core1_reset(void);
+void core1_trigger_reset(void);
+
+/* Wait for core 1 to respond that it is ready for a new payload */
+void core1_wait_ready(void);
 
 /* Load a payload into core 1 */
 void core1_load(void *ivt, char *args);

epicardium/main.c

-#include <stdio.h>
-#include <stdlib.h>
-
-#include <ff.h>
-
-#include "max32665.h"
-#include "uart.h"
-#include "cdcacm.h"
-#include "gpio.h"
-
-#include "card10.h"
-#include "pmic.h"
-#include "leds.h"
-#include "api/dispatcher.h"
 #include "modules/modules.h"
 #include "modules/log.h"
-#include "modules/stream.h"
-#include "modules/filesystem.h"
-#include "api/interrupt-sender.h"
-
-#include "Heart.h"
-#include "gfx.h"
-#include "display.h"
 #include "card10-version.h"
 
 #include "FreeRTOS.h"
 #include "task.h"
 
+#include <stdlib.h>
+
 TaskHandle_t dispatcher_task_id;
 
 void vBleTask(void *pvParameters);
@@ -35,46 +16,9 @@ int main(void)
 	LOG_INFO("startup", "Epicardium startup ...");
 	LOG_INFO("startup", "Version " CARD10_VERSION);
 
+	LOG_INFO("startup", "Initializing hardware ...");
 	hardware_early_init();
 
-#ifdef CARD10_DEBUG_CORE1
-	LOG_WARN("startup", "Core 1 Debugger Mode");
-	static const gpio_cfg_t swclk = {
-		PORT_0,
-		PIN_7,
-		GPIO_FUNC_ALT3,
-		GPIO_PAD_NONE,
-	};
-	static const gpio_cfg_t swdio = {
-		PORT_0,
-		PIN_6,
-		GPIO_FUNC_ALT3,
-		GPIO_PAD_NONE,
-	};
-
-	GPIO_Config(&swclk);
-	GPIO_Config(&swdio);
-#endif /* CARD10_DEBUG_CORE1 */
-
-	gfx_copy_region_raw(
-		&display_screen, 0, 0, 160, 80, 2, (const void *)(Heart)
-	);
-	gfx_update(&display_screen);
-
-	/* TODO: Move this to its own function */
-	SCB->SCR |= SCB_SCR_SEVONPEND_Msk;
-
-	if (cdcacm_init() < 0) {
-		LOG_ERR("startup", "USB-Serial unavailable");
-	}
-
-	fatfs_init();
-	api_interrupt_init();
-	stream_init();
-
-	LOG_INFO("startup", "Initializing dispatcher ...");
-	api_dispatcher_init();
-
 	LOG_INFO("startup", "Initializing tasks ...");
 
 	/* Serial */
@@ -129,10 +73,6 @@ int main(void)
 		abort();
 	}
 
-	/* light sensor */
-	LOG_INFO("startup", "starting light sensor ...");
-	epic_light_sensor_run();
-
 	/* Lifecycle */
 	if (xTaskCreate(
 		    vLifecycleTask,

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 "modules/modules.h"
+#include "modules/stream.h"
 
 #include "card10.h"
+#include "display.h"
+#include "leds.h"
+#include "pb.h"
+#include "pmic.h"
+#include "portexpander.h"
+
+#include "gpio.h"
+#include "i2c.h"
+#include "spi.h"
 
 /*
  * Early init is called at the very beginning and is meant for modules which
@@ -9,7 +26,124 @@
  */
 int hardware_early_init(void)
 {
-	card10_init();
+	/*
+	 * I2C bus for onboard peripherals (ie. PMIC, BMA400, BHI160, BME680,
+	 * ...)
+	 */
+	I2C_Shutdown(MXC_I2C1_BUS0);
+	I2C_Init(MXC_I2C1_BUS0, I2C_FAST_MODE, NULL);
+
+#ifndef CARD10_DEBUG_CORE1
+	/*
+	 * SAO I2C bus
+	 */
+	I2C_Shutdown(MXC_I2C0_BUS0);
+	I2C_Init(MXC_I2C0_BUS0, I2C_FAST_MODE, NULL);
+#endif
+
+	/*
+	 * GPIO peripheral.
+	 */
+	GPIO_Init();
+
+	/*
+	 * PMIC (MAX77650)
+	 */
+	pmic_init();
+	pmic_set_led(0, 0);
+	pmic_set_led(1, 0);
+	pmic_set_led(2, 0);
+
+	/*
+	 * Harmonic Board Portexpander
+	 */
+	portexpander_init();
+
+	/*
+	 * Buttons
+	 */
+	PB_Init();
+
+	/*
+	 * SPI for ECG
+	 */
+	const sys_cfg_spi_t spi17y_master_cfg = {
+		.map = MAP_A,
+		.ss0 = Enable,
+		.ss1 = Disable,
+		.ss2 = Disable,
+	};
+
+	if (SPI_Init(SPI0, 0, SPI_SPEED, spi17y_master_cfg) != 0) {
+		LOG_ERR("init", "Error configuring SPI");
+		while (1)
+			;
+	}
+
+	/*
+	 * The bootloader has already initialized the display, so we only need
+	 * to do the bare minimum here (mostly the gfx datastructures).
+	 */
+	display_init_slim();
+
+	/*
+	 * RGB LEDs
+	 */
+	leds_init();
+
+#ifdef CARD10_DEBUG_CORE1
+	/*
+	 * The SAO pins can be reconfigured for SWCLK2 and SWDIO2 which allows
+	 * debugging core 1.  This feature can optionally be enabled at
+	 * compile-time.
+	 */
+	LOG_WARN("init", "Core 1 Debugger Mode");
+	static const gpio_cfg_t swclk = {
+		PORT_0,
+		PIN_7,
+		GPIO_FUNC_ALT3,
+		GPIO_PAD_NONE,
+	};
+	static const gpio_cfg_t swdio = {
+		PORT_0,
+		PIN_6,
+		GPIO_FUNC_ALT3,
+		GPIO_PAD_NONE,
+	};
+
+	GPIO_Config(&swclk);
+	GPIO_Config(&swdio);
+#endif /* CARD10_DEBUG_CORE1 */
+
+	/*
+	 * Enable SEV-ON-PEND which is needed for proper working of the FreeRTOS
+	 * tickless idle sleep in Epicardium.
+	 */
+	SCB->SCR |= SCB_SCR_SEVONPEND_Msk;
+
+	/*
+	 * USB-Serial
+	 */
+	if (cdcacm_init() < 0) {
+		LOG_ERR("init", "USB-Serial unavailable");
+	}
+
+	/*
+	 * Flash & FatFS
+	 */
+	fatfs_init();
+
+	/*
+	 * API Dispatcher & API Interrupts
+	 */
+	api_interrupt_init();
+	api_dispatcher_init();
+
+	/*
+	 * Sensor streams
+	 */
+	stream_init();
+
 	return 0;
 }
 
@@ -23,6 +157,10 @@ int hardware_early_init(void)
  */
 int hardware_init(void)
 {
+	/* Light Sensor */
+	LOG_INFO("init", "Starting light sensor ...");
+	epic_light_sensor_run();
+
 	return 0;
 }
 
@@ -35,6 +173,24 @@ int hardware_init(void)
  */
 int hardware_reset(void)
 {
-	card10_init();
+	/*
+	 * API Dispatcher & API Interrupts
+	 */
+	api_interrupt_init();
+	api_dispatcher_init();
+
+	/*
+	 * LEDs
+	 */
+	leds_init();
+	epic_leds_set_rocket(0, 0);
+	epic_leds_set_rocket(1, 0);
+	epic_leds_set_rocket(2, 0);
+
+	/*
+	 * Display
+	 */
+	display_init_slim();
+
 	return 0;
 }

epicardium/modules/lifecycle.c

@@ -2,6 +2,7 @@
 #include "modules/log.h"
 #include "modules/modules.h"
 #include "api/dispatcher.h"
+#include "api/interrupt-sender.h"
 #include "l0der/l0der.h"
 
 #include "card10.h"
@@ -87,6 +88,9 @@ static int load_stat(char *name)
  */
 static int do_load(struct load_info *info)
 {
+	struct l0dable_info l0dable;
+	int res;
+
 	if (*info->name == '\0') {
 		LOG_INFO("lifecycle", "Loading Python interpreter ...");
 	} else {
@@ -100,9 +104,21 @@ static int do_load(struct load_info *info)
 
 	if (info->do_reset) {
 		LOG_DEBUG("lifecycle", "Triggering core 1 reset.");
-		core1_reset();
 
-		api_dispatcher_init();
+		core1_trigger_reset();
+	}
+
+	/*
+	 * Wait for the core to become ready to accept a new payload.
+	 */
+	core1_wait_ready();
+
+	/*
+	 * Reinitialize Hardware & Drivers
+	 */
+	res = hardware_reset();
+	if (res < 0) {
+		return res;
 	}
 
 	switch (info->type) {
@@ -112,14 +128,7 @@ static int do_load(struct load_info *info)
 		core1_load(PYCARDIUM_IVT, info->name);
 		break;
 	case PL_L0DABLE:
-		/*
-		 * Always reset when loading a l0dable to make sure the memory
-		 * space is absolutely free.
-		 */
-		core1_reset();
-
-		struct l0dable_info l0dable;
-		int res = l0der_load_path(info->name, &l0dable);
+		res = l0der_load_path(info->name, &l0dable);
 		if (res != 0) {
 			LOG_ERR("lifecycle", "l0der failed: %d\n", res);
 			xSemaphoreGive(api_mutex);

lib/card10/card10.c

+#include "card10.h"
 #include "pmic.h"
 #include "bosch.h"
 #include "display.h"
@@ -24,8 +25,6 @@
 #include <stdint.h>
 #include <string.h>
 
-#define SPI_SPEED (15 * 1000 * 1000) // Bit Rate
-
 const gpio_cfg_t bhi_interrupt_pin = {
 	PORT_0, PIN_13, GPIO_FUNC_IN, GPIO_PAD_PULL_UP
 };

lib/card10/card10.h

@@ -4,6 +4,8 @@
 
 #include <stdint.h>
 
+#define SPI_SPEED (15 * 1000 * 1000) // Bit Rate
+
 extern const gpio_cfg_t bhi_interrupt_pin;
 
 void card10_init(void);

lib/card10/display.c

@@ -103,3 +103,18 @@ void display_init(void)
 	txt_init(&display_textb, &display_screen, &Font12);
 	gfx_clear(&display_screen);
 }
+
+void display_init_slim(void)
+{
+	if (!portexpander_detected()) {
+		// Open-drain
+		MAX77650_setDRV(false);
+		// Output
+		MAX77650_setDIR(false);
+	}
+
+	GPIO_Config(&DEV_DC_PIN);
+
+	display_screen = gfx_screen(LCD_framebuffer());
+	txt_init(&display_textb, &display_screen, &Font12);
+}

lib/card10/display.h

@@ -6,5 +6,6 @@ extern struct gfx_region display_screen;
 extern struct txt_buffer display_textb;
 
 void display_init(void);
+void display_init_slim(void);
 
 #endif

lib/gfx/textbuffer.c

@@ -12,8 +12,6 @@ void txt_init(struct txt_buffer *txtb, struct gfx_region *reg, sFONT *f)
 	txtb->bg_color      = gfx_color_rgb_f(reg, .0f, .0f, .0f);
 	txtb->draw_cursor   = 1;
 	txtb->auto_update   = 1;
-
-	txt_clear(txtb);
 }
 
 static inline size_t width_(struct txt_buffer *tm)

preload/menu.py

@@ -71,6 +71,13 @@ def main():
     numapps = len(applist)
     current = 0
     for ev in button_events():
+        if numapps == 0:
+            disp.clear()
+            disp.print("No apps", posy=0)
+            disp.print("available", posy=20)
+            disp.update()
+            continue
+
         if ev == buttons.BOTTOM_RIGHT:
             # Scroll down
             draw_menu(disp, applist, current, -8)

pycardium/modules/py/ledfx.py

@@ -2,6 +2,9 @@ import leds, utime, math
 
 
 def col_cor(colors, brightness=1, gamma=1):
+    """
+    Gamma and  brightness correction for the RGB channels
+    """
     return [
         [int(255 * brightness * math.pow((y / 255.0), gamma)) for y in x]
         for x in colors
@@ -9,8 +12,13 @@ def col_cor(colors, brightness=1, gamma=1):
 
 
 def halo(colors):
+    """ 
+    sets the four bottom/side LEDs to colors corresponding to the color spectrum on the outermost of the top 11 LEDs
+    """
     used_leds = len(colors)
+    #add additional RGB-Color-lists to the colors-list to fill up the top LEDs with emptiness
     colors += [[0, 0, 0]] * (11 - used_leds)
+    #add four additional colors. the last one, the first one twice, the last one. 
     colors += [colors[used_leds - 1]] + [colors[0]] * 2 + [colors[used_leds - 1]]
     return colors
 
@@ -22,29 +30,51 @@ def kitt(
     minimum=0.3,
     rgb=[255, 0, 0],
     spectrum=[],
+    
     halo=False,
 ):
     """
-    LED Animation.
+    LED Animation. Knight rider-Style. 
+    :param cycles: amount of cycles for the animation
+    :param delay: time in microseconds until the animation moves on. (we could also call it framerate)
+    :param power: the shape of your brightness curve. bigger values make a steeper curve, smaller values make the curve wider.
+    :param minimum: the minimal brightness
+    :param rgb: if you don't enter a spectrum this is the color we'll use
+    :param specttrum: a color spectrum consisting of up to 11 RGB-Value-Lists (e.g. [[255,255,255], [0,0,0], [255,255,255] and so on] - ). if you use less, the animation will be less wide.
     """
+    
+    # create a basic table of values for a smooth increment of the LED brightness (if you don't understand this, don't worry, i don't either. just paste it into the python shell and see the output). Basically creates a negative cosinus curve. 
     kitt_table = [((-math.cos(math.pi * (x / 10.0))) + 1) / 2.0 for x in range(21)]
+    #adjust the values to start with a minimum brightness and the width of the curve to the given power.
     kitt_table = [math.pow(x, power) * (1 - minimum) + minimum for x in kitt_table]
 
+    #for the amount of specified cycles 
     for i in range(cycles):
+        #repeat every 20 steps
         j = i % 20
+        #and go backwards after 10 steps
         if j > 10:
             j = 20 - j
+        #if a color spectrum wasn't given
         if spectrum == []:
+            #set the amount of LEDs used to 11, because we're using the full width
             used_leds = 11
-            output = [[int(x * y) for y in rgb] for x in kitt_table[j : (j + 11)]]
+            #set the color values to the LEDs by multiplying the given color value with the corresponding brightness value in the kitt table
+            output = [[int(x * y) for y in rgb] for x in kitt_table[j : (j + used_leds)]]
         else:
+            #use the amount of leds specified in the spectrum
             used_leds = len(spectrum)
+            #multiply the color values in the corresponding spectrum tuple with the brightness value in the kitt table
             output = [
                 [int(y * kitt_table[j + x]) for y in spectrum[x]]
                 for x in range(used_leds)
             ]
+        #if a halo is True, also use the four bottom LEDs
         if halo:
             halo(output)
+        #set the LEDs to the output defined above
         leds.set_all(output)
+        #sleep for the amount of milliseconds specified in delay
         utime.sleep_ms(delay)
+    #Switch off all LEDs.
     leds.clear()

pycardium/modules/py/pov.py

+#this script reads a BMP file and displays it as POV. For optimal results use a BMP that is 11 pixels wide.
+
+import leds,utime
+#default filename. Depending on how you want to run this, change it
+FILENAME = "Smiley.bmp"
+#Determines the Frame Rate, currently not used.
+DELAY = 0
+#Determine Brightness Level. You might not wanna use the full values from the BMP
+BRIGHTNESS = 1.0
+
+
+
+class BMPError(Exception):
+    pass
+
+class POV: 
+    def __init__(self, filename=FILENAME):
+        self.filename = filename
+        f = open("/" + self.filename, "rb")
+        if f.read(2) != b'BM':  # check signature
+            raise BMPError("Not BitMap file")
+        #turn into int.from_bytes
+        bmpFileSize = int.from_bytes(f.read(4), 'little')
+        f.read(4)  # Read & ignore creator bytes
+
+        self.bmpImageOffset = self.read_le(f.read(4))  # Start of image data
+        headerSize = self.read_le(f.read(4))
+        self.bmpWidth = self.read_le(f.read(4))
+        self.bmpHeight = self.read_le(f.read(4))
+        flip = False
+
+        print("Size: %d\nImage offset: %d\nHeader size: %d" %
+              (bmpFileSize, self.bmpImageOffset, headerSize))
+        print("Width: %d\nHeight: %d" % (self.bmpWidth, self.bmpHeight))
+
+        if self.read_le(f.read(2)) != 1:
+            raise BMPError("Not singleplane")
+        bmpDepth = self.read_le(f.read(2))  # bits per pixel
+        print("Bit depth: %d" % (bmpDepth))
+        if bmpDepth != 24:
+            raise BMPError("Not 24-bit")
+        if self.read_le(f.read(2)) != 0:
+            raise BMPError("Compressed file")
+
+        print("Image OK!")
+        self.rowSize = (self.bmpWidth * 3 + 3) & ~3  # 32-bit line boundary
+        self.fileOffset = f.tell()
+        print("File Offset"+str(self.fileOffset))
+        f.close()
+        self.read_image()
+
+
+    def correct_brightness(self, color):
+        return int(pow((color * BRIGHTNESS) / 255, 2.7) * 255 + 0.5)
+    def getWidth(self):
+        return self.bmpWidth
+    def setFileOffset(self, fileOffset):
+        self.fileOffset = fileOffset
+    def getFileOffset(self):
+        return self.fileOffset
+    def read_le(self, bytes):
+        return int.from_bytes(bytes, 'little')
+    def read_image(self): 
+        self.imageArray = []
+        flip = True
+        rowSize = (self.bmpWidth * 3 + 3) & ~3
+        f = open("/" + self.filename, "rb")
+        for row in range(self.bmpHeight):
+            rowArray = []
+            if flip:  # Bitmap is stored bottom-to-top order (normal BMP)
+                pos = self.bmpImageOffset + (self.bmpHeight - 1 - row) * rowSize
+            else:  # Bitmap is stored top-to-bottom
+                pos = self.bmpImageOffset + row * rowSize
+            f.seek(pos)
+            for col in range(self.bmpWidth):
+                rgb = [f.read(1), f.read(1), f.read(1)]
+                rgb = [int.from_bytes(x, "little") for x in rgb]
+                #rgb = [self.correct_brightness(x) for x in rgb]
+                rowArray += [rgb]
+            self.imageArray += [rowArray]
+
+    def getImageArray(self):
+        return self.imageArray
+    
+    def playMe(self):
+        for i in self.imageArray:
+            leds.set_all(i)
+
+def play(imagename):
+    myPov = POV(imagename)
+    while True:
+        myPov.playMe()
+
+
+play("Smiley.bmp")