[FL-1942] Applications: Display Test. u8g2 usage refactoring. #770

applications/applications.c

@@ -19,8 +19,11 @@ extern int32_t desktop_srv(void* p);
 // Apps
 extern int32_t accessor_app(void* p);
 extern int32_t archive_app(void* p);
+extern int32_t bad_usb_app(void* p);
 extern int32_t blink_test_app(void* p);
+extern int32_t bt_debug_app(void* p);
 extern int32_t delay_test_app(void* p);
+extern int32_t display_test_app(void* p);
 extern int32_t gpio_app(void* p);
 extern int32_t ibutton_app(void* p);
 extern int32_t irda_app(void* p);
@@ -32,11 +35,9 @@ extern int32_t nfc_app(void* p);
 extern int32_t scened_app(void* p);
 extern int32_t storage_test_app(void* p);
 extern int32_t subghz_app(void* p);
-extern int32_t vibro_test_app(void* p);
-extern int32_t bt_debug_app(void* p);
-extern int32_t usb_test_app(void* p);
 extern int32_t usb_mouse_app(void* p);
-extern int32_t bad_usb_app(void* p);
+extern int32_t usb_test_app(void* p);
+extern int32_t vibro_test_app(void* p);
 
 // Plugins
 extern int32_t music_player_app(void* p);
@@ -208,43 +209,43 @@ const size_t FLIPPER_PLUGINS_COUNT = sizeof(FLIPPER_PLUGINS) / sizeof(FlipperApp
 // Plugin menu
 const FlipperApplication FLIPPER_DEBUG_APPS[] = {
 #ifdef APP_BLINK
-    {.app = blink_test_app, .name = "Blink Test", .stack_size = 1024, .icon = &A_Plugins_14},
+    {.app = blink_test_app, .name = "Blink Test", .stack_size = 1024, .icon = NULL},
 #endif
 
-#ifdef APP_VIBRO_DEMO
-    {.app = vibro_test_app, .name = "Vibro Test", .stack_size = 1024, .icon = &A_Plugins_14},
+#ifdef APP_VIBRO_TEST
+    {.app = vibro_test_app, .name = "Vibro Test", .stack_size = 1024, .icon = NULL},
 #endif
 
 #ifdef APP_KEYPAD_TEST
-    {.app = keypad_test_app, .name = "Keypad Test", .stack_size = 1024, .icon = &A_Plugins_14},
+    {.app = keypad_test_app, .name = "Keypad Test", .stack_size = 1024, .icon = NULL},
 #endif
 
 #ifdef APP_ACCESSOR
-    {.app = accessor_app, .name = "Accessor", .stack_size = 4096, .icon = &A_Plugins_14},
+    {.app = accessor_app, .name = "Accessor", .stack_size = 4096, .icon = NULL},
 #endif
 
 #ifdef APP_USB_TEST
-    {.app = usb_test_app, .name = "USB Test", .stack_size = 1024, .icon = &A_Plugins_14},
+    {.app = usb_test_app, .name = "USB Test", .stack_size = 1024, .icon = NULL},
 #endif
 
 #ifdef APP_USB_MOUSE
-    {.app = usb_mouse_app, .name = "USB Mouse demo", .stack_size = 1024, .icon = &A_Plugins_14},
+    {.app = usb_mouse_app, .name = "USB Mouse demo", .stack_size = 1024, .icon = NULL},
 #endif
 
 #ifdef APP_BAD_USB
-    {.app = bad_usb_app, .name = "Bad USB test", .stack_size = 2048, .icon = &A_Plugins_14},
+    {.app = bad_usb_app, .name = "Bad USB test", .stack_size = 2048, .icon = NULL},
 #endif
 
 #ifdef APP_IRDA_MONITOR
-    {.app = irda_monitor_app, .name = "Irda Monitor", .stack_size = 1024, .icon = &A_Plugins_14},
+    {.app = irda_monitor_app, .name = "Irda Monitor", .stack_size = 1024, .icon = NULL},
 #endif
 
 #ifdef APP_SCENED
-    {.app = scened_app, .name = "Templated Scene", .stack_size = 1024, .icon = &A_Plugins_14},
+    {.app = scened_app, .name = "Templated Scene", .stack_size = 1024, .icon = NULL},
 #endif
 
 #ifdef APP_LF_RFID
-    {.app = lfrfid_debug_app, .name = "LF-RFID Debug", .stack_size = 1024, .icon = &A_125khz_14},
+    {.app = lfrfid_debug_app, .name = "LF-RFID Debug", .stack_size = 1024, .icon = NULL},
 #endif
 
 #ifdef SRV_BT
@@ -252,7 +253,11 @@ const FlipperApplication FLIPPER_DEBUG_APPS[] = {
 #endif
 
 #ifdef APP_UNIT_TESTS
-    {.app = delay_test_app, .name = "Delay Test App", .stack_size = 1024, .icon = &A_Plugins_14},
+    {.app = delay_test_app, .name = "Delay Test", .stack_size = 1024, .icon = NULL},
+#endif
+
+#ifdef APP_DISPLAY_TEST
+    {.app = display_test_app, .name = "Display Test", .stack_size = 1024, .icon = NULL},
 #endif
 };
 

applications/applications.mk

@@ -38,12 +38,14 @@ APP_MUSIC_PLAYER = 1
 
 # Debug
 APP_ACCESSOR = 1
-APP_BLINK	= 1
+APP_BLINK = 1
 APP_IRDA_MONITOR = 1
 APP_KEYPAD_TEST = 1
 APP_SD_TEST	= 1
-APP_VIBRO_DEMO = 1
+APP_VIBRO_TEST = 1
 APP_USB_TEST = 1
+APP_DISPLAY_TEST = 1
+
 APP_USB_MOUSE = 1
 APP_BAD_USB = 1
 endif
@@ -117,9 +119,9 @@ SRV_GUI		= 1
 endif
 
 
-APP_VIBRO_DEMO ?= 0
-ifeq ($(APP_VIBRO_DEMO), 1)
-CFLAGS		+= -DAPP_VIBRO_DEMO
+APP_VIBRO_TEST ?= 0
+ifeq ($(APP_VIBRO_TEST), 1)
+CFLAGS		+= -DAPP_VIBRO_TEST
 SRV_GUI		= 1
 endif
 
@@ -127,21 +129,26 @@ endif
 APP_USB_TEST ?= 0
 ifeq ($(APP_USB_TEST), 1)
 CFLAGS		+= -DAPP_USB_TEST
-SRV_INPUT = 1
 SRV_GUI = 1
 endif
 
+
+APP_DISPLAY_TEST ?= 0
+ifeq ($(APP_DISPLAY_TEST), 1)
+CFLAGS		+= -DAPP_DISPLAY_TEST
+SRV_GUI = 1
+endif
+
+
 APP_USB_MOUSE ?= 0
 ifeq ($(APP_USB_MOUSE), 1)
 CFLAGS		+= -DAPP_USB_MOUSE
-SRV_INPUT = 1
 SRV_GUI = 1
 endif
 
 APP_BAD_USB ?= 0
 ifeq ($(APP_BAD_USB), 1)
 CFLAGS		+= -DAPP_BAD_USB
-SRV_INPUT = 1
 SRV_GUI = 1
 endif 
 

applications/debug_tools/display_test/display_test.c

@@ -0,0 +1,100 @@
+#include "display_test.h"
+
+#include <furi-hal.h>
+#include <furi.h>
+
+#include <gui/gui.h>
+#include <gui/view_dispatcher.h>
+#include <gui/modules/submenu.h>
+#include <gui/modules/variable-item-list.h>
+
+#include "view_display_test.h"
+
+typedef struct {
+    Gui* gui;
+    ViewDispatcher* view_dispatcher;
+    ViewDisplayTest* view_display_test;
+    VariableItemList* variable_item_list;
+    Submenu* submenu;
+} DisplayTest;
+
+typedef enum {
+    DisplayTestViewSubmenu,
+    DisplayTestViewConfigure,
+    DisplayTestViewDisplayTest,
+} DisplayTestView;
+
+static void display_test_submenu_callback(void* context, uint32_t index) {
+    DisplayTest* instance = (DisplayTest*)context;
+
+    view_dispatcher_switch_to_view(instance->view_dispatcher, index);
+}
+
+static uint32_t display_test_previous_callback(void* context) {
+    return DisplayTestViewSubmenu;
+}
+
+static uint32_t display_test_exit_callback(void* context) {
+    return VIEW_NONE;
+}
+
+DisplayTest* display_test_alloc() {
+    DisplayTest* instance = furi_alloc(sizeof(DisplayTest));
+
+    View* view = NULL;
+
+    instance->gui = furi_record_open("gui");
+    instance->view_dispatcher = view_dispatcher_alloc();
+
+    instance->view_display_test = view_display_test_alloc();
+    view_dispatcher_enable_queue(instance->view_dispatcher);
+    view_dispatcher_attach_to_gui(
+        instance->view_dispatcher, instance->gui, ViewDispatcherTypeFullscreen);
+    view = view_display_test_get_view(instance->view_display_test);
+    view_set_previous_callback(view, display_test_previous_callback);
+    view_dispatcher_add_view(instance->view_dispatcher, DisplayTestViewDisplayTest, view);
+
+    instance->submenu = submenu_alloc();
+    view = submenu_get_view(instance->submenu);
+    view_set_previous_callback(view, display_test_exit_callback);
+    view_dispatcher_add_view(instance->view_dispatcher, DisplayTestViewSubmenu, view);
+    submenu_add_item(
+        instance->submenu,
+        "Test",
+        DisplayTestViewDisplayTest,
+        display_test_submenu_callback,
+        instance);
+    // submenu_add_item(instance->submenu, "Configure", DisplayTestViewConfigure, display_test_submenu_callback, instance);
+
+    return instance;
+}
+
+void display_test_free(DisplayTest* instance) {
+    view_dispatcher_remove_view(instance->view_dispatcher, DisplayTestViewSubmenu);
+    submenu_free(instance->submenu);
+
+    view_dispatcher_remove_view(instance->view_dispatcher, DisplayTestViewDisplayTest);
+    view_display_test_free(instance->view_display_test);
+
+    view_dispatcher_free(instance->view_dispatcher);
+    furi_record_close("gui");
+
+    free(instance);
+}
+
+int32_t display_test_run(DisplayTest* instance) {
+    view_dispatcher_switch_to_view(instance->view_dispatcher, DisplayTestViewSubmenu);
+    view_dispatcher_run(instance->view_dispatcher);
+
+    return 0;
+}
+
+int32_t display_test_app(void* p) {
+    DisplayTest* instance = display_test_alloc();
+
+    int32_t ret = display_test_run(instance);
+
+    display_test_free(instance);
+
+    return ret;
+}

applications/debug_tools/display_test/display_test.h

@@ -0,0 +1 @@
+#pragma once

applications/debug_tools/display_test/view_display_test.c

@@ -0,0 +1,185 @@
+#include "view_display_test.h"
+
+typedef struct {
+    uint32_t test;
+    uint32_t size;
+    uint32_t counter;
+    bool flip_flop;
+} ViewDisplayTestModel;
+
+struct ViewDisplayTest {
+    View* view;
+    osTimerId_t timer;
+};
+
+static void view_display_test_draw_callback_intro(Canvas* canvas, void* _model) {
+    canvas_draw_str(canvas, 12, 24, "Use < and > to switch tests");
+    canvas_draw_str(canvas, 12, 36, "Use ^ and v to switch size");
+    canvas_draw_str(canvas, 32, 48, "Use (o) to flip");
+}
+
+static void view_display_test_draw_callback_fill(Canvas* canvas, void* _model) {
+    ViewDisplayTestModel* model = _model;
+    if(model->flip_flop) {
+        uint8_t width = canvas_width(canvas);
+        uint8_t height = canvas_height(canvas);
+        canvas_draw_box(canvas, 0, 0, width, height);
+    }
+}
+
+static void view_display_test_draw_callback_hstripe(Canvas* canvas, void* _model) {
+    ViewDisplayTestModel* model = _model;
+    uint8_t block = 1 + model->size;
+    uint8_t width = canvas_width(canvas);
+    uint8_t height = canvas_height(canvas);
+
+    for(uint8_t y = model->flip_flop * block; y < height; y += 2 * block) {
+        canvas_draw_box(canvas, 0, y, width, block);
+    }
+}
+
+static void view_display_test_draw_callback_vstripe(Canvas* canvas, void* _model) {
+    ViewDisplayTestModel* model = _model;
+    uint8_t block = 1 + model->size;
+    uint8_t width = canvas_width(canvas);
+    uint8_t height = canvas_height(canvas);
+
+    for(uint8_t x = model->flip_flop * block; x < width; x += 2 * block) {
+        canvas_draw_box(canvas, x, 0, block, height);
+    }
+}
+
+static void view_display_test_draw_callback_check(Canvas* canvas, void* _model) {
+    ViewDisplayTestModel* model = _model;
+    uint8_t block = 1 + model->size;
+    uint8_t width = canvas_width(canvas);
+    uint8_t height = canvas_height(canvas);
+
+    bool flip_flop = model->flip_flop;
+    for(uint8_t x = 0; x < width; x += block) {
+        bool last_flip_flop = flip_flop;
+        for(uint8_t y = 0; y < height; y += block) {
+            if(flip_flop) {
+                canvas_draw_box(canvas, x, y, block, block);
+            }
+            flip_flop = !flip_flop;
+        }
+        if(last_flip_flop == flip_flop) {
+            flip_flop = !flip_flop;
+        }
+    }
+}
+
+static void view_display_test_draw_callback_move(Canvas* canvas, void* _model) {
+    ViewDisplayTestModel* model = _model;
+    uint8_t block = 1 + model->size;
+    uint8_t width = canvas_width(canvas) - block;
+    uint8_t height = canvas_height(canvas) - block;
+
+    uint8_t x = model->counter % width;
+    if((model->counter / width) % 2) {
+        x = width - x;
+    }
+
+    uint8_t y = model->counter % height;
+    if((model->counter / height) % 2) {
+        y = height - y;
+    }
+
+    canvas_draw_box(canvas, x, y, block, block);
+}
+
+ViewDrawCallback view_display_test_tests[] = {
+    view_display_test_draw_callback_intro,
+    view_display_test_draw_callback_fill,
+    view_display_test_draw_callback_hstripe,
+    view_display_test_draw_callback_vstripe,
+    view_display_test_draw_callback_check,
+    view_display_test_draw_callback_move,
+};
+
+static void view_display_test_draw_callback(Canvas* canvas, void* _model) {
+    ViewDisplayTestModel* model = _model;
+    view_display_test_tests[model->test](canvas, _model);
+}
+
+static bool view_display_test_input_callback(InputEvent* event, void* context) {
+    ViewDisplayTest* instance = context;
+
+    bool consumed = false;
+    if(event->type == InputTypeShort || event->type == InputTypeRepeat) {
+        with_view_model(
+            instance->view, (ViewDisplayTestModel * model) {
+                if(event->key == InputKeyLeft && model->test > 0) {
+                    model->test--;
+                    consumed = true;
+                } else if(
+                    event->key == InputKeyRight &&
+                    model->test < (COUNT_OF(view_display_test_tests) - 1)) {
+                    model->test++;
+                    consumed = true;
+                } else if(event->key == InputKeyDown && model->size > 0) {
+                    model->size--;
+                    consumed = true;
+                } else if(event->key == InputKeyUp && model->size < 24) {
+                    model->size++;
+                    consumed = true;
+                } else if(event->key == InputKeyOk) {
+                    model->flip_flop = !model->flip_flop;
+                    consumed = true;
+                }
+                return consumed;
+            });
+    }
+
+    return consumed;
+}
+
+static void view_display_test_enter(void* context) {
+    ViewDisplayTest* instance = context;
+    osTimerStart(instance->timer, osKernelGetTickFreq() / 32);
+}
+
+static void view_display_test_exit(void* context) {
+    ViewDisplayTest* instance = context;
+    osTimerStop(instance->timer);
+}
+
+static void view_display_test_timer_callback(void* context) {
+    ViewDisplayTest* instance = context;
+    with_view_model(
+        instance->view, (ViewDisplayTestModel * model) {
+            model->counter++;
+            return true;
+        });
+}
+
+ViewDisplayTest* view_display_test_alloc() {
+    ViewDisplayTest* instance = furi_alloc(sizeof(ViewDisplayTest));
+
+    instance->view = view_alloc();
+    view_set_context(instance->view, instance);
+    view_allocate_model(instance->view, ViewModelTypeLockFree, sizeof(ViewDisplayTestModel));
+    view_set_draw_callback(instance->view, view_display_test_draw_callback);
+    view_set_input_callback(instance->view, view_display_test_input_callback);
+    view_set_enter_callback(instance->view, view_display_test_enter);
+    view_set_exit_callback(instance->view, view_display_test_exit);
+
+    instance->timer =
+        osTimerNew(view_display_test_timer_callback, osTimerPeriodic, instance, NULL);
+
+    return instance;
+}
+
+void view_display_test_free(ViewDisplayTest* instance) {
+    furi_assert(instance);
+
+    osTimerDelete(instance->timer);
+    view_free(instance->view);
+    free(instance);
+}
+
+View* view_display_test_get_view(ViewDisplayTest* instance) {
+    furi_assert(instance);
+    return instance->view;
+}

applications/debug_tools/display_test/view_display_test.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <stdint.h>
+#include <gui/view.h>
+
+typedef struct ViewDisplayTest ViewDisplayTest;
+
+ViewDisplayTest* view_display_test_alloc();
+
+void view_display_test_free(ViewDisplayTest* instance);
+
+View* view_display_test_get_view(ViewDisplayTest* instance);

applications/gui/canvas.c

@@ -4,9 +4,7 @@
 
 #include <furi.h>
 #include <furi-hal.h>
-
-uint8_t u8g2_gpio_and_delay_stm32(u8x8_t* u8x8, uint8_t msg, uint8_t arg_int, void* arg_ptr);
-uint8_t u8x8_hw_spi_stm32(u8x8_t* u8x8, uint8_t msg, uint8_t arg_int, void* arg_ptr);
+#include <u8g2_glue.h>
 
 Canvas* canvas_init() {
     Canvas* canvas = furi_alloc(sizeof(Canvas));
@@ -14,8 +12,7 @@ Canvas* canvas_init() {
     furi_hal_power_insomnia_enter();
 
     canvas->orientation = CanvasOrientationHorizontal;
-    u8g2_Setup_st7565_erc12864_alt_f(
-        &canvas->fb, U8G2_R0, u8x8_hw_spi_stm32, u8g2_gpio_and_delay_stm32);
+    u8g2_Setup_st756x_erc(&canvas->fb, U8G2_R0, u8x8_hw_spi_stm32, u8g2_gpio_and_delay_stm32);
 
     // send init sequence to the display, display is in sleep mode after this
     u8g2_InitDisplay(&canvas->fb);

applications/gui/u8g2_periphery.c

@@ -1,68 +0,0 @@
-#include "u8g2/u8g2.h"
-#include <furi-hal.h>
-#include <furi.h>
-
-static FuriHalSpiDevice* u8g2_periphery_display = NULL;
-
-uint8_t u8g2_gpio_and_delay_stm32(u8x8_t* u8x8, uint8_t msg, uint8_t arg_int, void* arg_ptr) {
-    switch(msg) {
-    case U8X8_MSG_GPIO_AND_DELAY_INIT:
-        /* HAL initialization contains all what we need so we can skip this part. */
-        break;
-
-    case U8X8_MSG_DELAY_MILLI:
-        osDelay(arg_int);
-        break;
-
-    case U8X8_MSG_DELAY_10MICRO:
-        delay_us(10);
-        break;
-
-    case U8X8_MSG_DELAY_100NANO:
-        asm("nop");
-        break;
-
-    case U8X8_MSG_GPIO_RESET:
-        hal_gpio_write(&gpio_display_rst, arg_int);
-        break;
-
-    default:
-        return 0;
-    }
-
-    return 1;
-}
-
-uint8_t u8x8_hw_spi_stm32(u8x8_t* u8x8, uint8_t msg, uint8_t arg_int, void* arg_ptr) {
-    switch(msg) {
-    case U8X8_MSG_BYTE_SEND:
-        furi_hal_spi_bus_tx(u8g2_periphery_display->bus, (uint8_t*)arg_ptr, arg_int, 10000);
-        break;
-
-    case U8X8_MSG_BYTE_SET_DC:
-        hal_gpio_write(&gpio_display_di, arg_int);
-        break;
-
-    case U8X8_MSG_BYTE_INIT:
-        break;
-
-    case U8X8_MSG_BYTE_START_TRANSFER:
-        furi_assert(u8g2_periphery_display == NULL);
-        u8g2_periphery_display =
-            (FuriHalSpiDevice*)furi_hal_spi_device_get(FuriHalSpiDeviceIdDisplay);
-        hal_gpio_write(u8g2_periphery_display->chip_select, false);
-        break;
-
-    case U8X8_MSG_BYTE_END_TRANSFER:
-        furi_assert(u8g2_periphery_display);
-        hal_gpio_write(u8g2_periphery_display->chip_select, true);
-        furi_hal_spi_device_return(u8g2_periphery_display);
-        u8g2_periphery_display = NULL;
-        break;
-
-    default:
-        return 0;
-    }
-
-    return 1;
-}