init Files

libraries/lvgl/examples/porting/lv_port_disp_template.c

@@ -0,0 +1,149 @@
+/**
+ * @file lv_port_disp_templ.c
+ *
+ */
+
+/*Copy this file as "lv_port_disp.c" and set this value to "1" to enable content*/
+#if 0
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_port_disp_template.h"
+#include <stdbool.h>
+
+/*********************
+ *      DEFINES
+ *********************/
+#ifndef MY_DISP_HOR_RES
+    #warning Please define or replace the macro MY_DISP_HOR_RES with the actual screen width, default value 320 is used for now.
+    #define MY_DISP_HOR_RES    320
+#endif
+
+#ifndef MY_DISP_VER_RES
+    #warning Please define or replace the macro MY_DISP_VER_RES with the actual screen height, default value 240 is used for now.
+    #define MY_DISP_VER_RES    240
+#endif
+
+#define BYTE_PER_PIXEL (LV_COLOR_FORMAT_GET_SIZE(LV_COLOR_FORMAT_RGB565)) /*will be 2 for RGB565 */
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void disp_init(void);
+
+static void disp_flush(lv_display_t * disp, const lv_area_t * area, uint8_t * px_map);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_port_disp_init(void)
+{
+    /*-------------------------
+     * Initialize your display
+     * -----------------------*/
+    disp_init();
+
+    /*------------------------------------
+     * Create a display and set a flush_cb
+     * -----------------------------------*/
+    lv_display_t * disp = lv_display_create(MY_DISP_HOR_RES, MY_DISP_VER_RES);
+    lv_display_set_flush_cb(disp, disp_flush);
+
+    /* Example 1
+     * One buffer for partial rendering*/
+    LV_ATTRIBUTE_MEM_ALIGN
+    static uint8_t buf_1_1[MY_DISP_HOR_RES * 10 * BYTE_PER_PIXEL];            /*A buffer for 10 rows*/
+    lv_display_set_buffers(disp, buf_1_1, NULL, sizeof(buf_1_1), LV_DISPLAY_RENDER_MODE_PARTIAL);
+
+    /* Example 2
+     * Two buffers for partial rendering
+     * In flush_cb DMA or similar hardware should be used to update the display in the background.*/
+    LV_ATTRIBUTE_MEM_ALIGN
+    static uint8_t buf_2_1[MY_DISP_HOR_RES * 10 * BYTE_PER_PIXEL];
+
+    LV_ATTRIBUTE_MEM_ALIGN
+    static uint8_t buf_2_2[MY_DISP_HOR_RES * 10 * BYTE_PER_PIXEL];
+    lv_display_set_buffers(disp, buf_2_1, buf_2_2, sizeof(buf_2_1), LV_DISPLAY_RENDER_MODE_PARTIAL);
+
+    /* Example 3
+     * Two buffers screen sized buffer for double buffering.
+     * Both LV_DISPLAY_RENDER_MODE_DIRECT and LV_DISPLAY_RENDER_MODE_FULL works, see their comments*/
+    LV_ATTRIBUTE_MEM_ALIGN
+    static uint8_t buf_3_1[MY_DISP_HOR_RES * MY_DISP_VER_RES * BYTE_PER_PIXEL];
+
+    LV_ATTRIBUTE_MEM_ALIGN
+    static uint8_t buf_3_2[MY_DISP_HOR_RES * MY_DISP_VER_RES * BYTE_PER_PIXEL];
+    lv_display_set_buffers(disp, buf_3_1, buf_3_2, sizeof(buf_3_1), LV_DISPLAY_RENDER_MODE_DIRECT);
+
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/*Initialize your display and the required peripherals.*/
+static void disp_init(void)
+{
+    /*You code here*/
+}
+
+volatile bool disp_flush_enabled = true;
+
+/* Enable updating the screen (the flushing process) when disp_flush() is called by LVGL
+ */
+void disp_enable_update(void)
+{
+    disp_flush_enabled = true;
+}
+
+/* Disable updating the screen (the flushing process) when disp_flush() is called by LVGL
+ */
+void disp_disable_update(void)
+{
+    disp_flush_enabled = false;
+}
+
+/*Flush the content of the internal buffer the specific area on the display.
+ *`px_map` contains the rendered image as raw pixel map and it should be copied to `area` on the display.
+ *You can use DMA or any hardware acceleration to do this operation in the background but
+ *'lv_display_flush_ready()' has to be called when it's finished.*/
+static void disp_flush(lv_display_t * disp_drv, const lv_area_t * area, uint8_t * px_map)
+{
+    if(disp_flush_enabled) {
+        /*The most simple case (but also the slowest) to put all pixels to the screen one-by-one*/
+
+        int32_t x;
+        int32_t y;
+        for(y = area->y1; y <= area->y2; y++) {
+            for(x = area->x1; x <= area->x2; x++) {
+                /*Put a pixel to the display. For example:*/
+                /*put_px(x, y, *px_map)*/
+                px_map++;
+            }
+        }
+    }
+
+    /*IMPORTANT!!!
+     *Inform the graphics library that you are ready with the flushing*/
+    lv_display_flush_ready(disp_drv);
+}
+
+#else /*Enable this file at the top*/
+
+/*This dummy typedef exists purely to silence -Wpedantic.*/
+typedef int keep_pedantic_happy;
+#endif

libraries/lvgl/examples/porting/lv_port_disp_template.h

@@ -0,0 +1,57 @@
+/**
+ * @file lv_port_disp_templ.h
+ *
+ */
+
+/*Copy this file as "lv_port_disp.h" and set this value to "1" to enable content*/
+#if 0
+
+#ifndef LV_PORT_DISP_TEMPL_H
+#define LV_PORT_DISP_TEMPL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#if defined(LV_LVGL_H_INCLUDE_SIMPLE)
+#include "lvgl.h"
+#else
+#include "lvgl/lvgl.h"
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+/* Initialize low level display driver */
+void lv_port_disp_init(void);
+
+/* Enable updating the screen (the flushing process) when disp_flush() is called by LVGL
+ */
+void disp_enable_update(void);
+
+/* Disable updating the screen (the flushing process) when disp_flush() is called by LVGL
+ */
+void disp_disable_update(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_PORT_DISP_TEMPL_H*/
+
+#endif /*Disable/Enable content*/

libraries/lvgl/examples/porting/lv_port_fs_template.c

@@ -0,0 +1,261 @@
+/**
+ * @file lv_port_fs_templ.c
+ *
+ */
+
+/*Copy this file as "lv_port_fs.c" and set this value to "1" to enable content*/
+#if 0
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_port_fs_template.h"
+#include "../../lvgl.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void fs_init(void);
+
+static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode);
+static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p);
+static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br);
+static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw);
+static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t whence);
+static lv_fs_res_t fs_size(lv_fs_drv_t * drv, void * file_p, uint32_t * size_p);
+static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p);
+
+static void * fs_dir_open(lv_fs_drv_t * drv, const char * path);
+static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * rddir_p, char * fn, uint32_t fn_len);
+static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * rddir_p);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_port_fs_init(void)
+{
+    /*----------------------------------------------------
+     * Initialize your storage device and File System
+     * -------------------------------------------------*/
+    fs_init();
+
+    /*---------------------------------------------------
+     * Register the file system interface in LVGL
+     *--------------------------------------------------*/
+
+    static lv_fs_drv_t fs_drv;
+    lv_fs_drv_init(&fs_drv);
+
+    /*Set up fields...*/
+    fs_drv.letter = 'P';
+    fs_drv.open_cb = fs_open;
+    fs_drv.close_cb = fs_close;
+    fs_drv.read_cb = fs_read;
+    fs_drv.write_cb = fs_write;
+    fs_drv.seek_cb = fs_seek;
+    fs_drv.tell_cb = fs_tell;
+
+    fs_drv.dir_close_cb = fs_dir_close;
+    fs_drv.dir_open_cb = fs_dir_open;
+    fs_drv.dir_read_cb = fs_dir_read;
+
+    lv_fs_drv_register(&fs_drv);
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/*Initialize your Storage device and File system.*/
+static void fs_init(void)
+{
+    /*E.g. for FatFS initialize the SD card and FatFS itself*/
+
+    /*You code here*/
+}
+
+/**
+ * Open a file
+ * @param drv       pointer to a driver where this function belongs
+ * @param path      path to the file beginning with the driver letter (e.g. S:/folder/file.txt)
+ * @param mode      read: FS_MODE_RD, write: FS_MODE_WR, both: FS_MODE_RD | FS_MODE_WR
+ * @return          a file descriptor or NULL on error
+ */
+static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode)
+{
+    lv_fs_res_t res = LV_FS_RES_NOT_IMP;
+
+    void * f = NULL;
+
+    if(mode == LV_FS_MODE_WR) {
+        /*Open a file for write*/
+        f = ...         /*Add your code here*/
+    }
+    else if(mode == LV_FS_MODE_RD) {
+        /*Open a file for read*/
+        f = ...         /*Add your code here*/
+    }
+    else if(mode == (LV_FS_MODE_WR | LV_FS_MODE_RD)) {
+        /*Open a file for read and write*/
+        f = ...         /*Add your code here*/
+    }
+
+    return f;
+}
+
+/**
+ * Close an opened file
+ * @param drv       pointer to a driver where this function belongs
+ * @param file_p    pointer to a file_t variable. (opened with fs_open)
+ * @return          LV_FS_RES_OK: no error or  any error from @lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p)
+{
+    lv_fs_res_t res = LV_FS_RES_NOT_IMP;
+
+    /*Add your code here*/
+
+    return res;
+}
+
+/**
+ * Read data from an opened file
+ * @param drv       pointer to a driver where this function belongs
+ * @param file_p    pointer to a file_t variable.
+ * @param buf       pointer to a memory block where to store the read data
+ * @param btr       number of Bytes To Read
+ * @param br        the real number of read bytes (Byte Read)
+ * @return          LV_FS_RES_OK: no error or  any error from @lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br)
+{
+    lv_fs_res_t res = LV_FS_RES_NOT_IMP;
+
+    /*Add your code here*/
+
+    return res;
+}
+
+/**
+ * Write into a file
+ * @param drv       pointer to a driver where this function belongs
+ * @param file_p    pointer to a file_t variable
+ * @param buf       pointer to a buffer with the bytes to write
+ * @param btw       Bytes To Write
+ * @param bw        the number of real written bytes (Bytes Written). NULL if unused.
+ * @return          LV_FS_RES_OK: no error or  any error from @lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw)
+{
+    lv_fs_res_t res = LV_FS_RES_NOT_IMP;
+
+    /*Add your code here*/
+
+    return res;
+}
+
+/**
+ * Set the read write pointer. Also expand the file size if necessary.
+ * @param drv       pointer to a driver where this function belongs
+ * @param file_p    pointer to a file_t variable. (opened with fs_open )
+ * @param pos       the new position of read write pointer
+ * @param whence    tells from where to interpret the `pos`. See @lv_fs_whence_t
+ * @return          LV_FS_RES_OK: no error or  any error from @lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t whence)
+{
+    lv_fs_res_t res = LV_FS_RES_NOT_IMP;
+
+    /*Add your code here*/
+
+    return res;
+}
+/**
+ * Give the position of the read write pointer
+ * @param drv       pointer to a driver where this function belongs
+ * @param file_p    pointer to a file_t variable
+ * @param pos_p     pointer to store the result
+ * @return          LV_FS_RES_OK: no error or  any error from @lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p)
+{
+    lv_fs_res_t res = LV_FS_RES_NOT_IMP;
+
+    /*Add your code here*/
+
+    return res;
+}
+
+/**
+ * Initialize a 'lv_fs_dir_t' variable for directory reading
+ * @param drv       pointer to a driver where this function belongs
+ * @param path      path to a directory
+ * @return          pointer to the directory read descriptor or NULL on error
+ */
+static void * fs_dir_open(lv_fs_drv_t * drv, const char * path)
+{
+    void * dir = NULL;
+    /*Add your code here*/
+    dir = ...           /*Add your code here*/
+          return dir;
+}
+
+/**
+ * Read the next filename form a directory.
+ * The name of the directories will begin with '/'
+ * @param drv       pointer to a driver where this function belongs
+ * @param rddir_p   pointer to an initialized 'lv_fs_dir_t' variable
+ * @param fn        pointer to a buffer to store the filename
+ * @param fn_len    length of the buffer to store the filename
+ * @return          LV_FS_RES_OK: no error or  any error from @lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * rddir_p, char * fn, uint32_t fn_len)
+{
+    lv_fs_res_t res = LV_FS_RES_NOT_IMP;
+
+    /*Add your code here*/
+
+    return res;
+}
+
+/**
+ * Close the directory reading
+ * @param drv       pointer to a driver where this function belongs
+ * @param rddir_p   pointer to an initialized 'lv_fs_dir_t' variable
+ * @return          LV_FS_RES_OK: no error or  any error from @lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * rddir_p)
+{
+    lv_fs_res_t res = LV_FS_RES_NOT_IMP;
+
+    /*Add your code here*/
+
+    return res;
+}
+
+#else /*Enable this file at the top*/
+
+/*This dummy typedef exists purely to silence -Wpedantic.*/
+typedef int keep_pedantic_happy;
+#endif

libraries/lvgl/examples/porting/lv_port_fs_template.h

@@ -0,0 +1,44 @@
+/**
+ * @file lv_port_fs_templ.h
+ *
+ */
+
+/*Copy this file as "lv_port_fs.h" and set this value to "1" to enable content*/
+#if 0
+
+#ifndef LV_PORT_FS_TEMPL_H
+#define LV_PORT_FS_TEMPL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lvgl/lvgl.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+void lv_port_fs_init(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_PORT_FS_TEMPL_H*/
+
+#endif /*Disable/Enable content*/

libraries/lvgl/examples/porting/lv_port_indev_template.c

@@ -0,0 +1,406 @@
+/**
+ * @file lv_port_indev_templ.c
+ *
+ */
+
+/*Copy this file as "lv_port_indev.c" and set this value to "1" to enable content*/
+#if 0
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_port_indev_template.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+static void touchpad_init(void);
+static void touchpad_read(lv_indev_t * indev, lv_indev_data_t * data);
+static bool touchpad_is_pressed(void);
+static void touchpad_get_xy(int32_t * x, int32_t * y);
+
+static void mouse_init(void);
+static void mouse_read(lv_indev_t * indev, lv_indev_data_t * data);
+static bool mouse_is_pressed(void);
+static void mouse_get_xy(int32_t * x, int32_t * y);
+
+static void keypad_init(void);
+static void keypad_read(lv_indev_t * indev, lv_indev_data_t * data);
+static uint32_t keypad_get_key(void);
+
+static void encoder_init(void);
+static void encoder_read(lv_indev_t * indev, lv_indev_data_t * data);
+static void encoder_handler(void);
+
+static void button_init(void);
+static void button_read(lv_indev_t * indev, lv_indev_data_t * data);
+static int8_t button_get_pressed_id(void);
+static bool button_is_pressed(uint8_t id);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+lv_indev_t * indev_touchpad;
+lv_indev_t * indev_mouse;
+lv_indev_t * indev_keypad;
+lv_indev_t * indev_encoder;
+lv_indev_t * indev_button;
+
+static int32_t encoder_diff;
+static lv_indev_state_t encoder_state;
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_port_indev_init(void)
+{
+    /**
+     * Here you will find example implementation of input devices supported by LittelvGL:
+     *  - Touchpad
+     *  - Mouse (with cursor support)
+     *  - Keypad (supports GUI usage only with key)
+     *  - Encoder (supports GUI usage only with: left, right, push)
+     *  - Button (external buttons to press points on the screen)
+     *
+     *  The `..._read()` function are only examples.
+     *  You should shape them according to your hardware
+     */
+
+    /*------------------
+     * Touchpad
+     * -----------------*/
+
+    /*Initialize your touchpad if you have*/
+    touchpad_init();
+
+    /*Register a touchpad input device*/
+    indev_touchpad = lv_indev_create();
+    lv_indev_set_type(indev_touchpad, LV_INDEV_TYPE_POINTER);
+    lv_indev_set_read_cb(indev_touchpad, touchpad_read);
+
+    /*------------------
+     * Mouse
+     * -----------------*/
+
+    /*Initialize your mouse if you have*/
+    mouse_init();
+
+    /*Register a mouse input device*/
+    indev_mouse = lv_indev_create();
+    lv_indev_set_type(indev_mouse, LV_INDEV_TYPE_POINTER);
+    lv_indev_set_read_cb(indev_mouse, mouse_read);
+
+    /*Set cursor. For simplicity set a HOME symbol now.*/
+    lv_obj_t * mouse_cursor = lv_image_create(lv_screen_active());
+    lv_image_set_src(mouse_cursor, LV_SYMBOL_HOME);
+    lv_indev_set_cursor(indev_mouse, mouse_cursor);
+
+    /*------------------
+     * Keypad
+     * -----------------*/
+
+    /*Initialize your keypad or keyboard if you have*/
+    keypad_init();
+
+    /*Register a keypad input device*/
+    indev_keypad = lv_indev_create();
+    lv_indev_set_type(indev_keypad, LV_INDEV_TYPE_KEYPAD);
+    lv_indev_set_read_cb(indev_keypad, keypad_read);
+
+    /*Later you should create group(s) with `lv_group_t * group = lv_group_create()`,
+     *add objects to the group with `lv_group_add_obj(group, obj)`
+     *and assign this input device to group to navigate in it:
+     *`lv_indev_set_group(indev_keypad, group);`*/
+
+    /*------------------
+     * Encoder
+     * -----------------*/
+
+    /*Initialize your encoder if you have*/
+    encoder_init();
+
+    /*Register a encoder input device*/
+    indev_encoder = lv_indev_create();
+    lv_indev_set_type(indev_encoder, LV_INDEV_TYPE_ENCODER);
+    lv_indev_set_read_cb(indev_encoder, encoder_read);
+
+    /*Later you should create group(s) with `lv_group_t * group = lv_group_create()`,
+     *add objects to the group with `lv_group_add_obj(group, obj)`
+     *and assign this input device to group to navigate in it:
+     *`lv_indev_set_group(indev_encoder, group);`*/
+
+    /*------------------
+     * Button
+     * -----------------*/
+
+    /*Initialize your button if you have*/
+    button_init();
+
+    /*Register a button input device*/
+    indev_button = lv_indev_create();
+    lv_indev_set_type(indev_button, LV_INDEV_TYPE_BUTTON);
+    lv_indev_set_read_cb(indev_button, button_read);
+
+    /*Assign buttons to points on the screen*/
+    static const lv_point_t btn_points[2] = {
+        {10, 10},   /*Button 0 -> x:10; y:10*/
+        {40, 100},  /*Button 1 -> x:40; y:100*/
+    };
+    lv_indev_set_button_points(indev_button, btn_points);
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/*------------------
+ * Touchpad
+ * -----------------*/
+
+/*Initialize your touchpad*/
+static void touchpad_init(void)
+{
+    /*Your code comes here*/
+}
+
+/*Will be called by the library to read the touchpad*/
+static void touchpad_read(lv_indev_t * indev_drv, lv_indev_data_t * data)
+{
+    static int32_t last_x = 0;
+    static int32_t last_y = 0;
+
+    /*Save the pressed coordinates and the state*/
+    if(touchpad_is_pressed()) {
+        touchpad_get_xy(&last_x, &last_y);
+        data->state = LV_INDEV_STATE_PRESSED;
+    }
+    else {
+        data->state = LV_INDEV_STATE_RELEASED;
+    }
+
+    /*Set the last pressed coordinates*/
+    data->point.x = last_x;
+    data->point.y = last_y;
+}
+
+/*Return true is the touchpad is pressed*/
+static bool touchpad_is_pressed(void)
+{
+    /*Your code comes here*/
+
+    return false;
+}
+
+/*Get the x and y coordinates if the touchpad is pressed*/
+static void touchpad_get_xy(int32_t * x, int32_t * y)
+{
+    /*Your code comes here*/
+
+    (*x) = 0;
+    (*y) = 0;
+}
+
+/*------------------
+ * Mouse
+ * -----------------*/
+
+/*Initialize your mouse*/
+static void mouse_init(void)
+{
+    /*Your code comes here*/
+}
+
+/*Will be called by the library to read the mouse*/
+static void mouse_read(lv_indev_t * indev_drv, lv_indev_data_t * data)
+{
+    /*Get the current x and y coordinates*/
+    mouse_get_xy(&data->point.x, &data->point.y);
+
+    /*Get whether the mouse button is pressed or released*/
+    if(mouse_is_pressed()) {
+        data->state = LV_INDEV_STATE_PRESSED;
+    }
+    else {
+        data->state = LV_INDEV_STATE_RELEASED;
+    }
+}
+
+/*Return true is the mouse button is pressed*/
+static bool mouse_is_pressed(void)
+{
+    /*Your code comes here*/
+
+    return false;
+}
+
+/*Get the x and y coordinates if the mouse is pressed*/
+static void mouse_get_xy(int32_t * x, int32_t * y)
+{
+    /*Your code comes here*/
+
+    (*x) = 0;
+    (*y) = 0;
+}
+
+/*------------------
+ * Keypad
+ * -----------------*/
+
+/*Initialize your keypad*/
+static void keypad_init(void)
+{
+    /*Your code comes here*/
+}
+
+/*Will be called by the library to read the mouse*/
+static void keypad_read(lv_indev_t * indev_drv, lv_indev_data_t * data)
+{
+    static uint32_t last_key = 0;
+
+    /*Get the current x and y coordinates*/
+    mouse_get_xy(&data->point.x, &data->point.y);
+
+    /*Get whether the a key is pressed and save the pressed key*/
+    uint32_t act_key = keypad_get_key();
+    if(act_key != 0) {
+        data->state = LV_INDEV_STATE_PRESSED;
+
+        /*Translate the keys to LVGL control characters according to your key definitions*/
+        switch(act_key) {
+            case 1:
+                act_key = LV_KEY_NEXT;
+                break;
+            case 2:
+                act_key = LV_KEY_PREV;
+                break;
+            case 3:
+                act_key = LV_KEY_LEFT;
+                break;
+            case 4:
+                act_key = LV_KEY_RIGHT;
+                break;
+            case 5:
+                act_key = LV_KEY_ENTER;
+                break;
+        }
+
+        last_key = act_key;
+    }
+    else {
+        data->state = LV_INDEV_STATE_RELEASED;
+    }
+
+    data->key = last_key;
+}
+
+/*Get the currently being pressed key.  0 if no key is pressed*/
+static uint32_t keypad_get_key(void)
+{
+    /*Your code comes here*/
+
+    return 0;
+}
+
+/*------------------
+ * Encoder
+ * -----------------*/
+
+/*Initialize your encoder*/
+static void encoder_init(void)
+{
+    /*Your code comes here*/
+}
+
+/*Will be called by the library to read the encoder*/
+static void encoder_read(lv_indev_t * indev_drv, lv_indev_data_t * data)
+{
+
+    data->enc_diff = encoder_diff;
+    data->state = encoder_state;
+}
+
+/*Call this function in an interrupt to process encoder events (turn, press)*/
+static void encoder_handler(void)
+{
+    /*Your code comes here*/
+
+    encoder_diff += 0;
+    encoder_state = LV_INDEV_STATE_RELEASED;
+}
+
+/*------------------
+ * Button
+ * -----------------*/
+
+/*Initialize your buttons*/
+static void button_init(void)
+{
+    /*Your code comes here*/
+}
+
+/*Will be called by the library to read the button*/
+static void button_read(lv_indev_t * indev_drv, lv_indev_data_t * data)
+{
+
+    static uint8_t last_btn = 0;
+
+    /*Get the pressed button's ID*/
+    int8_t btn_act = button_get_pressed_id();
+
+    if(btn_act >= 0) {
+        data->state = LV_INDEV_STATE_PRESSED;
+        last_btn = btn_act;
+    }
+    else {
+        data->state = LV_INDEV_STATE_RELEASED;
+    }
+
+    /*Save the last pressed button's ID*/
+    data->btn_id = last_btn;
+}
+
+/*Get ID  (0, 1, 2 ..) of the pressed button*/
+static int8_t button_get_pressed_id(void)
+{
+    uint8_t i;
+
+    /*Check to buttons see which is being pressed (assume there are 2 buttons)*/
+    for(i = 0; i < 2; i++) {
+        /*Return the pressed button's ID*/
+        if(button_is_pressed(i)) {
+            return i;
+        }
+    }
+
+    /*No button pressed*/
+    return -1;
+}
+
+/*Test if `id` button is pressed or not*/
+static bool button_is_pressed(uint8_t id)
+{
+
+    /*Your code comes here*/
+
+    return false;
+}
+
+#else /*Enable this file at the top*/
+
+/*This dummy typedef exists purely to silence -Wpedantic.*/
+typedef int keep_pedantic_happy;
+#endif

libraries/lvgl/examples/porting/lv_port_indev_template.h

@@ -0,0 +1,49 @@
+
+/**
+ * @file lv_port_indev_templ.h
+ *
+ */
+
+/*Copy this file as "lv_port_indev.h" and set this value to "1" to enable content*/
+#if 0
+
+#ifndef LV_PORT_INDEV_TEMPL_H
+#define LV_PORT_INDEV_TEMPL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#if defined(LV_LVGL_H_INCLUDE_SIMPLE)
+#include "lvgl.h"
+#else
+#include "lvgl/lvgl.h"
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+void lv_port_indev_init(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_PORT_INDEV_TEMPL_H*/
+
+#endif /*Disable/Enable content*/

libraries/lvgl/examples/porting/lv_port_lcd_stm32_template.c

@@ -0,0 +1,183 @@
+/**
+ * @file lv_port_lcd_stm32_template.c
+ *
+ * Example implementation of the LVGL LCD display drivers on the STM32 platform
+ */
+
+/*Copy this file as "lv_port_disp.c" and set this value to "1" to enable content*/
+#if 0
+
+/*********************
+ *      INCLUDES
+ *********************/
+/* Include STM32Cube files here, e.g.:
+#include "stm32f7xx_hal.h"
+*/
+
+#include "lv_port_disp.h"
+#include "./src/drivers/display/st7789/lv_st7789.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#ifndef MY_DISP_HOR_RES
+    #warning Please define or replace the macro MY_DISP_HOR_RES with the actual screen width, default value 320 is used for now.
+    #define MY_DISP_HOR_RES    320
+#endif
+
+#ifndef MY_DISP_VER_RES
+    #warning Please define or replace the macro MY_DISP_VER_RES with the actual screen height, default value 240 is used for now.
+    #define MY_DISP_VER_RES    240
+#endif
+
+#define BUS_SPI1_POLL_TIMEOUT 0x1000U
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void lcd_color_transfer_ready_cb(SPI_HandleTypeDef * hspi);
+static int32_t lcd_io_init(void);
+static void lcd_send_cmd(lv_display_t * disp, const uint8_t * cmd, size_t cmd_size, const uint8_t * param,
+                         size_t param_size);
+static void lcd_send_color(lv_display_t * disp, const uint8_t * cmd, size_t cmd_size, uint8_t * param,
+                           size_t param_size);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+static lv_display_t * lcd_disp;
+static volatile int lcd_bus_busy = 0;
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_port_display_init(void)
+{
+    /* Initialize LCD I/O */
+    if(lcd_io_init() != 0)
+        return;
+
+    /* Create the LVGL display object and the ST7789 LCD display driver */
+    lcd_disp = lv_st7789_create(MY_DISP_HOR_RES, MY_DISP_VER_RES, LV_LCD_FLAG_NONE, lcd_send_cmd, lcd_send_color);
+    lv_display_set_rotation(lcd_disp, LV_DISPLAY_ROTATION_270);     /* set landscape orientation */
+
+    /* Example: two dynamically allocated buffers for partial rendering */
+    uint8_t * buf1 = NULL;
+    uint8_t * buf2 = NULL;
+
+    uint32_t buf_size = MY_DISP_HOR_RES * MY_DISP_VER_RES / 10 * lv_color_format_get_size(lv_display_get_color_format(
+                                                                                              lcd_disp));
+
+    buf1 = lv_malloc(buf_size);
+    if(buf1 == NULL) {
+        LV_LOG_ERROR("display draw buffer malloc failed");
+        return;
+    }
+
+    buf2 = lv_malloc(buf_size);
+    if(buf2 == NULL) {
+        LV_LOG_ERROR("display buffer malloc failed");
+        lv_free(buf1);
+        return;
+    }
+    lv_display_set_buffers(lcd_disp, buf1, buf2, buf_size, LV_DISPLAY_RENDER_MODE_PARTIAL);
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/* Callback is called when background transfer finished */
+static void lcd_color_transfer_ready_cb(SPI_HandleTypeDef * hspi)
+{
+    /* CS high */
+    HAL_GPIO_WritePin(LCD_CS_GPIO_Port, LCD_CS_Pin, GPIO_PIN_SET);
+    lcd_bus_busy = 0;
+    lv_display_flush_ready(lcd_disp);
+}
+
+/* Initialize LCD I/O bus, reset LCD */
+static int32_t lcd_io_init(void)
+{
+    /* Register SPI Tx Complete Callback */
+    HAL_SPI_RegisterCallback(&hspi1, HAL_SPI_TX_COMPLETE_CB_ID, lcd_color_transfer_ready_cb);
+
+    /* reset LCD */
+    HAL_GPIO_WritePin(LCD_RESET_GPIO_Port, LCD_RESET_Pin, GPIO_PIN_RESET);
+    HAL_Delay(100);
+    HAL_GPIO_WritePin(LCD_RESET_GPIO_Port, LCD_RESET_Pin, GPIO_PIN_SET);
+    HAL_Delay(100);
+
+    HAL_GPIO_WritePin(LCD_CS_GPIO_Port, LCD_CS_Pin, GPIO_PIN_SET);
+    HAL_GPIO_WritePin(LCD_DCX_GPIO_Port, LCD_DCX_Pin, GPIO_PIN_SET);
+
+    return HAL_OK;
+}
+
+/* Platform-specific implementation of the LCD send command function. In general this should use polling transfer. */
+static void lcd_send_cmd(lv_display_t * disp, const uint8_t * cmd, size_t cmd_size, const uint8_t * param,
+                         size_t param_size)
+{
+    LV_UNUSED(disp);
+    while(lcd_bus_busy);    /* wait until previous transfer is finished */
+    /* Set the SPI in 8-bit mode */
+    hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
+    HAL_SPI_Init(&hspi1);
+    /* DCX low (command) */
+    HAL_GPIO_WritePin(LCD_DCX_GPIO_Port, LCD_DCX_Pin, GPIO_PIN_RESET);
+    /* CS low */
+    HAL_GPIO_WritePin(LCD_CS_GPIO_Port, LCD_CS_Pin, GPIO_PIN_RESET);
+    /* send command */
+    if(HAL_SPI_Transmit(&hspi1, cmd, cmd_size, BUS_SPI1_POLL_TIMEOUT) == HAL_OK) {
+        /* DCX high (data) */
+        HAL_GPIO_WritePin(LCD_DCX_GPIO_Port, LCD_DCX_Pin, GPIO_PIN_SET);
+        /* for short data blocks we use polling transfer */
+        HAL_SPI_Transmit(&hspi1, (uint8_t *)param, (uint16_t)param_size, BUS_SPI1_POLL_TIMEOUT);
+        /* CS high */
+        HAL_GPIO_WritePin(LCD_CS_GPIO_Port, LCD_CS_Pin, GPIO_PIN_SET);
+    }
+}
+
+/* Platform-specific implementation of the LCD send color function. For better performance this should use DMA transfer.
+ * In case of a DMA transfer a callback must be installed to notify LVGL about the end of the transfer.
+ */
+static void lcd_send_color(lv_display_t * disp, const uint8_t * cmd, size_t cmd_size, uint8_t * param,
+                           size_t param_size)
+{
+    LV_UNUSED(disp);
+    while(lcd_bus_busy);    /* wait until previous transfer is finished */
+    /* Set the SPI in 8-bit mode */
+    hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
+    HAL_SPI_Init(&hspi1);
+    /* DCX low (command) */
+    HAL_GPIO_WritePin(LCD_DCX_GPIO_Port, LCD_DCX_Pin, GPIO_PIN_RESET);
+    /* CS low */
+    HAL_GPIO_WritePin(LCD_CS_GPIO_Port, LCD_CS_Pin, GPIO_PIN_RESET);
+    /* send command */
+    if(HAL_SPI_Transmit(&hspi1, cmd, cmd_size, BUS_SPI1_POLL_TIMEOUT) == HAL_OK) {
+        /* DCX high (data) */
+        HAL_GPIO_WritePin(LCD_DCX_GPIO_Port, LCD_DCX_Pin, GPIO_PIN_SET);
+        /* for color data use DMA transfer */
+        /* Set the SPI in 16-bit mode to match endianness */
+        hspi1.Init.DataSize = SPI_DATASIZE_16BIT;
+        HAL_SPI_Init(&hspi1);
+        lcd_bus_busy = 1;
+        HAL_SPI_Transmit_DMA(&hspi1, param, (uint16_t)param_size / 2);
+        /* NOTE: CS will be reset in the transfer ready callback */
+    }
+}
+
+#else /*Enable this file at the top*/
+
+/*This dummy typedef exists purely to silence -Wpedantic.*/
+typedef int keep_pedantic_happy;
+#endif

libraries/lvgl/examples/porting/lv_port_lcd_stm32_template.h

@@ -0,0 +1,49 @@
+/**
+ * @file lv_port_lcd_stm32_template.h
+ *
+ */
+
+/*Copy this file as "lv_port_disp.h" and set this value to "1" to enable content*/
+#if 0
+
+#ifndef LV_PORT_LCD_STM32_TEMPL_H
+#define LV_PORT_LCD_STM32_TEMPL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#if defined(LV_LVGL_H_INCLUDE_SIMPLE)
+#include "lvgl.h"
+#else
+#include "lvgl/lvgl.h"
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+/* Initialize low level display driver */
+void lv_port_disp_init(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_PORT_LCD_STM32_TEMPL_H*/
+
+#endif /*Disable/Enable content*/

libraries/lvgl/examples/porting/osal/lv_example_osal.c

@@ -0,0 +1,95 @@
+/**
+ * @file lv_example_osal.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../../lv_examples.h"
+
+#if LV_BUILD_EXAMPLES
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void counter_button_event_cb(lv_event_t * e);
+static void increment_thread_entry(void * user_data);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+static lv_thread_sync_t press_sync;
+static lv_thread_t increment_thread;
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_example_osal(void)
+{
+    lv_obj_t * counter_button;
+
+    counter_button = lv_button_create(lv_screen_active());
+    lv_obj_align(counter_button, LV_ALIGN_CENTER, 0, -15);
+    lv_obj_add_event_cb(counter_button, counter_button_event_cb, LV_EVENT_CLICKED, NULL);
+
+    if(lv_thread_sync_init(&press_sync) != LV_RESULT_OK) {
+        LV_LOG_ERROR("Error initializing thread sync");
+    }
+
+    if(lv_thread_init(&increment_thread, LV_THREAD_PRIO_MID, increment_thread_entry, 2048, NULL) != LV_RESULT_OK) {
+        LV_LOG_ERROR("Error initializing thread");
+    }
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void counter_button_event_cb(lv_event_t * e)
+{
+    LV_UNUSED(e);
+    if(lv_thread_sync_signal(&press_sync) != LV_RESULT_OK) {
+        LV_LOG_ERROR("Error signaling thread sync");
+    }
+}
+
+static void increment_thread_entry(void * user_data)
+{
+    LV_UNUSED(user_data);
+    lv_obj_t * counter_label;
+    uint32_t press_count = 0;
+
+    lv_lock();
+    counter_label = lv_label_create(lv_scr_act());
+    lv_obj_align(counter_label, LV_ALIGN_CENTER, 0, 0);
+    lv_label_set_text_fmt(counter_label, "Pressed %" LV_PRIu32 " times", press_count);
+    lv_unlock();
+
+    while(true) {
+        if(lv_thread_sync_wait(&press_sync) != LV_RESULT_OK) {
+            LV_LOG_ERROR("Error awaiting thread sync");
+        }
+        press_count += 1;
+
+        lv_lock();
+        lv_label_set_text_fmt(counter_label, "Pressed %" LV_PRIu32 " times", press_count);
+        lv_unlock();
+    }
+}
+
+
+#endif

libraries/lvgl/examples/porting/osal/lv_example_osal.h

@@ -0,0 +1,38 @@
+/**
+ * @file lv_example_osal.h
+ *
+ */
+
+#ifndef LV_EXAMPLE_OSAL_H
+#define LV_EXAMPLE_OSAL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+void lv_example_osal(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_EXAMPLE_OSAL_H*/