epicardium/epicardium.h

@@ -55,6 +55,9 @@ typedef _Bool bool;
 #define API_DISP_FRAMEBUFFER       0x29
 #define API_DISP_BACKLIGHT         0x2a
 #define API_DISP_PRINT_ADV         0x2b
+#define API_DISP_OVERLAY           0x2c
+#define API_DISP_SET_FULLSCREEN    0x2d
+#define API_DISP_IS_FULLSCREEN     0x2e
 
 /* API_BATTERY_VOLTAGE              0x30 */
 #define API_BATTERY_CURRENT        0x31
@@ -1306,6 +1309,36 @@ union disp_framebuffer {
  */
 API(API_DISP_OPEN, int epic_disp_open());
 
+/**
+ * Enable/disable fullscreen mode.
+ *
+ * Fullscreen will disable the overlay display.
+ *
+ * :param enable: ``true`` to enable fullscreen mode
+ * :return: ``0`` on success or a negative value in case of an error:
+ *
+ *    - ``-EBUSY``: Display was already locked from another task.
+ */
+API(API_DISP_SET_FULLSCREEN, int epic_disp_set_fullscreen(bool enable));
+
+/**
+ * Return fullscreen status. No lock is required.
+ *
+ * Fullscreen will disable the overlay display.
+ *
+ * :return: ``true`` if fullscreen is enabled
+ */
+API(API_DISP_IS_FULLSCREEN, bool epic_disp_is_fullscreen());
+
+/**
+ * Switch framebuffer to overlay.
+ *
+ * :return: ``0`` on success or a negative value in case of an error:
+ *
+ *    - ``-EBUSY``: Display was already locked from another task.
+ */
+API(API_DISP_OVERLAY, int epic_disp_overlay());
+
 /**
  * Unlocks the display again.
  *

epicardium/modules/display.c

@@ -3,6 +3,7 @@
 #include "FreeRTOS.h"
 #include "LCD_Driver.h"
 #include "epicardium.h"
+#include "framebuffer.h"
 #include "gfx.h"
 #include "gpio.h"
 #include "task.h"
@@ -11,6 +12,9 @@
 
 static TaskHandle_t lock = NULL;
 
+static struct gfx_region *current_fb = &application_screen;
+static bool fullscreen               = false;
+
 static int check_lock()
 {
 	TaskHandle_t task = xTaskGetCurrentTaskHandle();
@@ -71,7 +75,7 @@ int epic_disp_clear(uint16_t color)
 	if (cl < 0) {
 		return cl;
 	} else {
-		gfx_clear_to_color(&display_screen, color);
+		gfx_clear_to_color(current_fb, color);
 		return 0;
 	}
 }
@@ -82,7 +86,7 @@ int epic_disp_pixel(int16_t x, int16_t y, uint16_t color)
 	if (cl < 0) {
 		return cl;
 	} else {
-		gfx_setpixel(&display_screen, x, y, color);
+		gfx_setpixel(current_fb, x, y, color);
 		return 0;
 	}
 }
@@ -102,7 +106,7 @@ int epic_disp_line(
 	} else {
 		/* TODO add linestyle support to gfx code */
 		gfx_line(
-			&display_screen,
+			current_fb,
 			xstart,
 			ystart,
 			xend,
@@ -130,7 +134,7 @@ int epic_disp_rect(
 	switch (fillstyle) {
 	case FILLSTYLE_EMPTY:
 		gfx_rectangle(
-			&display_screen,
+			current_fb,
 			xstart,
 			ystart,
 			xend - xstart,
@@ -141,7 +145,7 @@ int epic_disp_rect(
 		break;
 	case FILLSTYLE_FILLED:
 		gfx_rectangle_fill(
-			&display_screen,
+			current_fb,
 			xstart,
 			ystart,
 			xend - xstart,
@@ -167,16 +171,47 @@ int epic_disp_circ(
 
 	switch (fillstyle) {
 	case FILLSTYLE_EMPTY:
-		gfx_circle(&display_screen, x, y, rad, pixelsize, color);
+		gfx_circle(current_fb, x, y, rad, pixelsize, color);
 		break;
 	case FILLSTYLE_FILLED:
-		gfx_circle_fill(&display_screen, x, y, rad, color);
+		gfx_circle_fill(current_fb, x, y, rad, color);
 		break;
 	}
 
 	return 0;
 }
 
+void compositor()
+{
+	/* Check that BPP is 2 for everything */
+	const size_t bpp_app  = fb_bytes_per_pixel(application_screen.fb);
+	const size_t bpp_ovl  = fb_bytes_per_pixel(overlay_screen.fb);
+	const size_t bpp_disp = fb_bytes_per_pixel(overlay_screen.fb);
+
+	if ((bpp_app != 2) || (bpp_ovl != 2) || (bpp_disp != 2))
+		return;
+
+	/* Compose overlay on application */
+	for (int y = 0; y < display_screen.height; y++) {
+		for (int x = 0; x < display_screen.width; x++) {
+			uint8_t *overlay_pixel =
+				fb_pixel(overlay_screen.fb, x, y);
+			uint8_t *target = fb_pixel(display_screen.fb, x, y);
+
+			if ((overlay_pixel[0] == 0) &&
+			    (overlay_pixel[1] == 0)) {
+				uint8_t *app_pixel =
+					fb_pixel(application_screen.fb, x, y);
+				target[0] = app_pixel[0];
+				target[1] = app_pixel[1];
+			} else {
+				target[0] = overlay_pixel[0];
+				target[1] = overlay_pixel[1];
+			}
+		}
+	}
+}
+
 int epic_disp_update()
 {
 	int cl = check_lock();
@@ -184,6 +219,10 @@ int epic_disp_update()
 		return cl;
 	}
 
+	if (!fullscreen) {
+		compositor();
+	}
+
 	gfx_update(&display_screen);
 	return 0;
 }
@@ -210,15 +249,48 @@ int epic_disp_open()
 {
 	TaskHandle_t task = xTaskGetCurrentTaskHandle();
 	if (lock == task) {
+		current_fb = fullscreen ? &display_screen : &application_screen;
 		return 0;
 	} else if (lock == NULL) {
 		lock       = task;
+		current_fb = fullscreen ? &display_screen : &application_screen;
 		return 0;
 	} else {
 		return -EBUSY;
 	}
 }
 
+int epic_disp_set_fullscreen(bool enable)
+{
+	int cl = check_lock();
+	if (cl < 0) {
+		return cl;
+	}
+
+	fullscreen = enable;
+
+	current_fb = fullscreen ? &display_screen : &application_screen;
+
+	return 0;
+}
+
+bool epic_disp_is_fullscreen()
+{
+	return fullscreen;
+}
+
+int epic_disp_overlay()
+{
+	int cl = check_lock();
+	if (cl < 0) {
+		return cl;
+	}
+
+	current_fb = &overlay_screen;
+
+	return 0;
+}
+
 int epic_disp_close()
 {
 	if (check_lock() < 0 && lock != NULL) {

lib/card10/display.c

@@ -16,6 +16,31 @@ const gpio_cfg_t DEV_DC_PIN = { PORT_1, PIN_6, GPIO_FUNC_OUT, GPIO_PAD_NONE };
 struct gfx_region display_screen;
 struct txt_buffer display_textb;
 
+/***** Virtual framebuffers *****/
+static uint8_t app_buffer[LCD_HEIGHT][LCD_WIDTH][2];
+static struct framebuffer app_framebuffer = { .data   = app_buffer,
+					      .width  = LCD_WIDTH,
+					      .height = LCD_HEIGHT,
+					      .stride = LCD_WIDTH * LCD_HEIGHT *
+							2,
+					      .orientation = FB_O_180,
+
+					      .update = NULL };
+
+struct gfx_region application_screen;
+
+static uint8_t ovl_buffer[LCD_HEIGHT][LCD_WIDTH][2];
+static struct framebuffer ovl_framebuffer = { .data   = ovl_buffer,
+					      .width  = LCD_WIDTH,
+					      .height = LCD_HEIGHT,
+					      .stride = LCD_WIDTH * LCD_HEIGHT *
+							2,
+					      .orientation = FB_O_180,
+
+					      .update = NULL };
+
+struct gfx_region overlay_screen;
+
 /***** Functions *****/
 void display_set_reset_pin(uint8_t state)
 {
@@ -43,6 +68,14 @@ void display_init(void)
 	display_screen = gfx_screen(LCD_framebuffer());
 	txt_init(&display_textb, &display_screen, &Font12);
 	gfx_clear(&display_screen);
+
+	app_framebuffer.encode_color_rgb = display_screen.fb->encode_color_rgb;
+	application_screen               = gfx_screen(&app_framebuffer);
+	gfx_clear(&application_screen);
+
+	ovl_framebuffer.encode_color_rgb = display_screen.fb->encode_color_rgb;
+	overlay_screen                   = gfx_screen(&ovl_framebuffer);
+	gfx_clear(&overlay_screen);
 }
 
 void display_init_slim(void)
@@ -58,4 +91,12 @@ void display_init_slim(void)
 
 	display_screen = gfx_screen(LCD_framebuffer());
 	txt_init(&display_textb, &display_screen, &Font12);
+
+	app_framebuffer.encode_color_rgb = display_screen.fb->encode_color_rgb;
+	application_screen               = gfx_screen(&app_framebuffer);
+	gfx_clear(&application_screen);
+
+	ovl_framebuffer.encode_color_rgb = display_screen.fb->encode_color_rgb;
+	overlay_screen                   = gfx_screen(&ovl_framebuffer);
+	gfx_clear(&overlay_screen);
 }

lib/card10/display.h

@@ -5,6 +5,9 @@
 extern struct gfx_region display_screen;
 extern struct txt_buffer display_textb;
 
+extern struct gfx_region application_screen;
+extern struct gfx_region overlay_screen;
+
 void display_init(void);
 void display_init_slim(void);
 

pycardium/modules/py/display.py

@@ -42,6 +42,19 @@ class Display:
         """
         return cls()
 
+    def set_fullscreen(self, enable):
+        """
+        Enable/disable fullscreen, so that overlays are not shown.
+        Will fail the display can't be locked
+        """
+        sys_display.set_fullscreen(enable)
+
+    def is_fullscreen(self):
+        """
+        Check if application is in fullscreen.
+        """
+        return sys_display.is_fullscreen()
+
     @staticmethod
     def close():
         """

pycardium/modules/qstrdefs.h

@@ -93,6 +93,8 @@ Q(read_thermistor_voltage)
 
 /* display */
 Q(sys_display)
+Q(set_fullscreen)
+Q(is_fullscreen)
 Q(display)
 Q(print)
 Q(print_adv)

pycardium/modules/sys_display.c

@@ -242,6 +242,29 @@ static mp_obj_t mp_display_open()
 }
 static MP_DEFINE_CONST_FUN_OBJ_0(display_open_obj, mp_display_open);
 
+static mp_obj_t mp_display_set_fullscreen(mp_obj_t enable_obj)
+{
+	int res = epic_disp_set_fullscreen(mp_obj_is_true(enable_obj));
+	if (res < 0) {
+		mp_raise_OSError(-res);
+	}
+	return mp_const_none;
+}
+static MP_DEFINE_CONST_FUN_OBJ_1(
+	display_set_fullscreen_obj, mp_display_set_fullscreen
+);
+
+static mp_obj_t mp_display_is_fullscreen()
+{
+	bool res = epic_disp_is_fullscreen();
+	return mp_obj_new_bool(res);
+}
+static MP_DEFINE_CONST_FUN_OBJ_0(
+	display_is_fullscreen_obj, mp_display_is_fullscreen
+);
+
+/* Overlay mode is not exposed to Python apps*/
+
 static mp_obj_t mp_display_close()
 {
 	int res = epic_disp_close();
@@ -256,6 +279,10 @@ static MP_DEFINE_CONST_FUN_OBJ_0(display_close_obj, mp_display_close);
 static const mp_rom_map_elem_t display_module_globals_table[] = {
 	{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_sys_display) },
 	{ MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&display_open_obj) },
+	{ MP_ROM_QSTR(MP_QSTR_set_fullscreen),
+	  MP_ROM_PTR(&display_set_fullscreen_obj) },
+	{ MP_ROM_QSTR(MP_QSTR_is_fullscreen),
+	  MP_ROM_PTR(&display_is_fullscreen_obj) },
 	{ MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&display_close_obj) },
 	{ MP_ROM_QSTR(MP_QSTR_print), MP_ROM_PTR(&display_print_obj) },
 	{ MP_ROM_QSTR(MP_QSTR_print_adv), MP_ROM_PTR(&display_print_adv_obj) },