LiJie
/
MXC-A36-Demo
11
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
MXC-A36-Demo/MCU/examples/turnkey/lvgl_Dashboard_8080/Src/app_lvgl.c

955 lines
27 KiB
C
Raw Blame History

#include "fr30xx.h"
#include "driver_display.h"
#include "driver_touchpad.h"
#include "driver_psram.h"
/* FreeRTOS kernel includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "co_util.h"
/* little file system */
#include "lfs_port.h"
/* LVGL includes */
#include "demos/lv_demos.h"
#include "app_config.h"
#include "app_lvgl.h"
#include "app_hw.h"
#include "fr_device_rtc.h"
#include "fr_device_encode.h"
#include "fr_device_vbat.h"
//task queue
#define GUI_TASK_QUEUE_LENGTH ( 64 )
#define SYS_TASK_QUEUE_LENGTH ( 64 )
//lvgl define
#if BOARD_SEL == BOARD_EVB_FR5090
#define LCD_HOR_SIZE (466)
#define LCD_VER_SIZE (466)
#elif BOARD_SEL == BOARD_EVB_FR3092E
#if 0 //DISPLAY_TYPE_ICNA3310
#define LCD_HOR_SIZE (466)
#define LCD_VER_SIZE (466)
#else
#define LCD_HOR_SIZE LV_HOR_RES_MAX
#define LCD_VER_SIZE LV_VER_RES_MAX
#endif
#elif BOARD_SEL == BOARD_EVB_FR3092E_CM
#define LCD_HOR_SIZE (368)
#define LCD_VER_SIZE (448)
#elif BOARD_SEL == BOARD_EVB_FR3092E_RGB
#define LCD_HOR_SIZE LV_HOR_RES_MAX
#define LCD_VER_SIZE LV_VER_RES_MAX
#else
#error "choose correct board"
#endif
#if (((LCD_HOR_SIZE - LV_HOR_RES_MAX) / 2 ) & 0x01)
#define HOR_OFFSET (((LCD_HOR_SIZE - LV_HOR_RES_MAX) / 2 ) + 0x01)
#else
#define HOR_OFFSET (((LCD_HOR_SIZE - LV_HOR_RES_MAX) / 2 ) + 0x00)
#endif
#if (((LCD_VER_SIZE - LV_VER_RES_MAX) / 2 ) & 0x01)
#define VER_OFFSET (((LCD_VER_SIZE - LV_VER_RES_MAX) / 2 ) + 0x01)
#else
#define VER_OFFSET (((LCD_VER_SIZE - LV_VER_RES_MAX) / 2 ) + 0x00)
#endif
#define LV_HOR_RES_MAX_ZOOM 258
#define LV_VER_RES_MAX_ZOOM 314
//#define IMG_BUFFER_VER 262
//#define DISPLAY_BUFFER_SIZE LV_HOR_RES_MAX*IMG_BUFFER_VER*LV_COLOR_DEPTH/8/sizeof(uint32_t)
#define DISPLAY_BUFFER_SIZE LV_HOR_RES_MAX*LV_VER_RES_MAX*LV_COLOR_DEPTH/8/sizeof(uint32_t)
#define DISPLAY_PSRAM_SIZE LV_HOR_RES_MAX*LV_VER_RES_MAX*LV_COLOR_DEPTH/8
#define DISPLAY_BLOCK_LINE DECODE_LINE_NUMBER
#define DISPLAY_BUFFER_20_LINE LV_HOR_RES_MAX*DISPLAY_BLOCK_LINE*LV_COLOR_DEPTH/8/sizeof(uint32_t)
DMA_HandleTypeDef dma_psram_handle;
/* used for DMA display */
static volatile bool display_dma_ongoing = false;
/* LVGL display buf enviroment */
static lv_disp_draw_buf_t disp_buf;
static lv_disp_drv_t * last_disp;
lv_indev_t * indev_keypad;
uint8_t key_code;
uint32_t display_framebuffer_block[DISPLAY_BUFFER_20_LINE+16];
uint32_t framebuffer_block_len = (DISPLAY_BUFFER_20_LINE+16) << 2;
//uint32_t display_framebuffer_bk[LV_HOR_RES_MAX*LV_VER_RES_MAX/2];
uint32_t display_framebuffer[DISPLAY_BUFFER_SIZE];
uint32_t display_framebuffer1[DISPLAY_BUFFER_SIZE];
//#define display_framebuffer1 display_framebuffer
#define LOAD_ORIG_FRAMEBUFFER (void *)PSRAM_DAC_BASE
#define LOAD_LEFT_FRAMEBUFFER (void *)(PSRAM_DAC_BASE + DISPLAY_PSRAM_SIZE)
#define LOAD_RIGHT_FRAMEBUFFER (void *)(PSRAM_DAC_BASE + DISPLAY_PSRAM_SIZE*2)
static QueueHandle_t gui_queue_handle;
static QueueHandle_t app_queue_handle;
static TaskHandle_t gui_task_Handle = NULL;
//过场特效的背景对<E699AF>?
const lv_img_dsc_t fetch_orig_img = {
.header.always_zero = 0,
.header.w = LV_HOR_RES_MAX,
.header.h = LV_VER_RES_MAX,
.data_size = LV_HOR_RES_MAX * LV_VER_RES_MAX * LV_COLOR_SIZE / 8,
.header.cf = LV_IMG_CF_TRUE_COLOR,
.header.reserved = 0,
.data = (const uint8_t *)display_framebuffer1,//(void *)PSRAM_DAC_BASE,
};
const lv_img_dsc_t fetch_orig_zoom_img = {
.header.always_zero = 0,
.header.w = LV_HOR_RES_MAX_ZOOM,
.header.h = LV_VER_RES_MAX_ZOOM,
.data_size = LV_HOR_RES_MAX_ZOOM * LV_VER_RES_MAX_ZOOM * LV_COLOR_SIZE / 8,
.header.cf = LV_IMG_CF_TRUE_COLOR,
.header.reserved = 0,
.data = (const uint8_t *)display_framebuffer1,//(void *)PSRAM_DAC_BASE,
};
const lv_img_dsc_t fetch_left_img = {
.header.always_zero = 0,
.header.w = LV_HOR_RES_MAX,
.header.h = LV_VER_RES_MAX,
.data_size = LV_HOR_RES_MAX * LV_VER_RES_MAX * LV_COLOR_SIZE / 8,
.header.cf = LV_IMG_CF_TRUE_COLOR,
.header.reserved = 0,
.data = LOAD_LEFT_FRAMEBUFFER,
};
const lv_img_dsc_t fetch_right_img = {
.header.always_zero = 0,
.header.w = LV_HOR_RES_MAX,
.header.h = LV_VER_RES_MAX,
.data_size = LV_HOR_RES_MAX * LV_VER_RES_MAX * LV_COLOR_SIZE / 8,
.header.cf = LV_IMG_CF_TRUE_COLOR,
.header.reserved = 0,
.data = LOAD_RIGHT_FRAMEBUFFER,
};
const lv_img_dsc_t fetch_disp_buf_img = {
.header.always_zero = 0,
.header.w = LV_HOR_RES_MAX,
.header.h = LV_VER_RES_MAX,
.data_size = LV_HOR_RES_MAX * LV_VER_RES_MAX * LV_COLOR_SIZE / 8,
.header.cf = LV_IMG_CF_TRUE_COLOR,
.header.reserved = 0,
.data = (const uint8_t *)display_framebuffer,
};
const lv_img_dsc_t fetch_disp_buf_zoom_img = {
.header.always_zero = 0,
.header.w = LV_HOR_RES_MAX_ZOOM,
.header.h = LV_VER_RES_MAX_ZOOM,
.data_size = LV_HOR_RES_MAX_ZOOM * LV_VER_RES_MAX_ZOOM * LV_COLOR_SIZE / 8,
.header.cf = LV_IMG_CF_TRUE_COLOR,
.header.reserved = 0,
.data = (const uint8_t *)display_framebuffer1 + (LV_HOR_RES_MAX * LV_VER_RES_MAX)
};
extern bool fetch_orig_buffer_flag;
extern bool fetch_orig_buffer_zoom_flag;
extern bool exit_disp_flush_flag;
extern bool fetch_disp_buffer_flag;
extern bool fetch_disp_buffer_zoom_flag;
void fr_app_mainUI0_func(lv_obj_t *parent);
void lv_prj_main(void);
static void setup_gui_running(void);
//----------------------------------------------------
//lvgl function
//----------------------------------------------------
// this function is when frame data is flushed
static void my_disp_flush_done(void)
{
lv_disp_flush_ready(last_disp);
}
void lv_disp_draw_buf_sw(bool sw)
{
lv_disp_t *disp = lv_disp_get_default();
if(disp == NULL) return;
disp->driver->full_refresh = 1;
if(sw)
{
lv_disp_draw_buf_init(&disp_buf, (void *)display_framebuffer, NULL, LV_HOR_RES_MAX * LV_VER_RES_MAX);
//printf("display_framebuffer \n");
}
else
{
lv_disp_draw_buf_init(&disp_buf, (void *)display_framebuffer_block, NULL, LV_HOR_RES_MAX * DISPLAY_BLOCK_LINE);
//printf("display_framebuffer_block \n");
}
lv_disp_drv_update(disp, disp->driver);
}
void lv_disp_buffer_copy(void)
{
//fputc('<', NULL);
volatile uint32_t * dst = display_framebuffer1;
volatile uint32_t * src = display_framebuffer;
for (uint32_t i=0; i<DISPLAY_PSRAM_SIZE/sizeof(uint32_t); i++) {
*dst++ = *src++;
}
//fputc('>', NULL);
}
bool lv_fetch_disp_buffer_func(const lv_area_t * area)
{
volatile uint32_t *dst ;
volatile uint32_t *src ;
// uint8_t * b_dst;
// uint8_t * b_src;
uint32_t i,j;
if(fetch_orig_buffer_zoom_flag)
{
//printf("disp w:%d,x:%d, h:%d,y:%d \n",(area->x2-area->x1+1),area->x1,(area->y2 - area->y1+1),area->y1);
//fputc('[', NULL);
// b_dst = (uint8_t *)display_framebuffer1;
// b_src = (uint8_t *)display_framebuffer;
// b_src += (LV_HOR_RES_MAX * ((LV_VER_RES_MAX - LV_VER_RES_MAX_ZOOM)/ 2) + ((LV_HOR_RES_MAX - LV_HOR_RES_MAX_ZOOM)/ 2)) * 2;
// for (i = 0; i < LV_VER_RES_MAX_ZOOM; i++)
// {
// memcpy(b_dst, b_src, LV_HOR_RES_MAX_ZOOM * 2);
// b_src += LV_HOR_RES_MAX * 2;
// b_dst += LV_HOR_RES_MAX_ZOOM * 2;
// }
dst = display_framebuffer1;
src = display_framebuffer;
src += (LV_HOR_RES_MAX * ((LV_VER_RES_MAX - LV_VER_RES_MAX_ZOOM)/ 2) + ((LV_HOR_RES_MAX - LV_HOR_RES_MAX_ZOOM)/ 2)) / 2;
for (i = 0; i < LV_VER_RES_MAX_ZOOM; i++)
{
for (j=0; j < LV_HOR_RES_MAX_ZOOM / 2; j++)
{
*dst++ = *src++;
}
src += (LV_HOR_RES_MAX - LV_HOR_RES_MAX_ZOOM) / 2;
}
//fputc(']', NULL);
}
if(fetch_disp_buffer_flag)
{
//printf("disp w:%d,x:%d, h:%d,y:%d \n",(area->x2-area->x1+1),area->x1,(area->y2 - area->y1+1),area->y1);
//printf("load disp buffer \n");
// dst = LOAD_LEFT_FRAMEBUFFER;
// src = display_framebuffer;
// for (i=0; i<DISPLAY_PSRAM_SIZE/sizeof(uint32_t); i++) {
// *dst++ = *src++;
// }
}
if(fetch_disp_buffer_zoom_flag)
{
//fputc('(', NULL);
// //img 2 address offset
// b_dst = (uint8_t *)display_framebuffer1;
// b_dst += (LV_HOR_RES_MAX * LV_VER_RES_MAX);
// b_src = (uint8_t *)display_framebuffer_block;
// uint16_t h = (area->y2 - area->y1 + 1);
// // printf("1 addr :%x \n",b_src);
// if(area->y1 <= ((LV_VER_RES_MAX - LV_VER_RES_MAX_ZOOM)/ 2))
// {
// b_src += (LV_HOR_RES_MAX * ((LV_VER_RES_MAX - LV_VER_RES_MAX_ZOOM)/ 2) + ((LV_HOR_RES_MAX - LV_HOR_RES_MAX_ZOOM)/ 2)) * 2;
// h -= ((LV_VER_RES_MAX - LV_VER_RES_MAX_ZOOM)/ 2);
// }
// else
// {
// // printf("dst height :%d \n",(area->y1 - ((LV_VER_RES_MAX - LV_VER_RES_MAX_ZOOM)/ 2)));
// b_dst += (LV_HOR_RES_MAX_ZOOM * (area->y1 - ((LV_VER_RES_MAX - LV_VER_RES_MAX_ZOOM)/ 2)) * 2);
// b_src += (LV_HOR_RES_MAX - LV_HOR_RES_MAX_ZOOM);
// if((area->y2 - ((LV_VER_RES_MAX - LV_VER_RES_MAX_ZOOM)/ 2)) >= LV_VER_RES_MAX_ZOOM)
// {
// if(h >= ((LV_VER_RES_MAX - LV_VER_RES_MAX_ZOOM)/ 2))
// {
// h -= ((LV_VER_RES_MAX - LV_VER_RES_MAX_ZOOM)/ 2);
// }
// else
// {
// h = 0;
// }
// }
// }
// // printf("next w:%d,x:%d, h:%d,y1:%d y2:%d, h:%d\n",(area->x2-area->x1+1),area->x1,(area->y2 - area->y1+1),area->y1,area->y2, h);
// // printf("2 addr :%x d addr %d\n",b_src, b_dst);
// for (i = 0; i < h; i++)
// {
// memcpy(b_dst, b_src, LV_HOR_RES_MAX_ZOOM * 2);
// b_src += LV_HOR_RES_MAX * 2;
// b_dst += LV_HOR_RES_MAX_ZOOM * 2;
// }
dst = display_framebuffer1;
dst += (LV_HOR_RES_MAX * LV_VER_RES_MAX) / 4;
src = display_framebuffer_block;
int16_t h = (area->y2 - area->y1 + 1);
// printf("1 addr :%x \n",b_src);
if(area->y1 <= ((LV_VER_RES_MAX - LV_VER_RES_MAX_ZOOM)/ 2))
{
src += (LV_HOR_RES_MAX * ((LV_VER_RES_MAX - LV_VER_RES_MAX_ZOOM)/ 2) + ((LV_HOR_RES_MAX - LV_HOR_RES_MAX_ZOOM)/ 2)) / 2;
h -= ((LV_VER_RES_MAX - LV_VER_RES_MAX_ZOOM)/ 2);
}
else
{
// printf("dst height :%d \n",(area->y1 - ((LV_VER_RES_MAX - LV_VER_RES_MAX_ZOOM)/ 2)));
dst += (LV_HOR_RES_MAX_ZOOM * (area->y1 - ((LV_VER_RES_MAX - LV_VER_RES_MAX_ZOOM)/ 2)) / 2);
src += (LV_HOR_RES_MAX - LV_HOR_RES_MAX_ZOOM) / 4;
if((area->y2 - ((LV_VER_RES_MAX - LV_VER_RES_MAX_ZOOM)/ 2)) >= LV_VER_RES_MAX_ZOOM)
{
if(h >= ((LV_VER_RES_MAX - LV_VER_RES_MAX_ZOOM)/ 2))
{
h -= ((LV_VER_RES_MAX - LV_VER_RES_MAX_ZOOM)/ 2);
}
else
{
h = 0;
}
}
}
// printf("next w:%d,x:%d, h:%d,y1:%d y2:%d, h:%d\n",(area->x2-area->x1+1),area->x1,(area->y2 - area->y1+1),area->y1,area->y2, h);
// printf("2 addr :%x d addr %d\n",b_src, b_dst);
for (i = 0; i < h; i++)
{
for (j=0; j < LV_HOR_RES_MAX_ZOOM / 2; j++)
{
*dst++ = *src++;
}
src += (LV_HOR_RES_MAX - LV_HOR_RES_MAX_ZOOM) / 2;
}
//fputc(')', NULL);
}
if(fetch_disp_buffer_flag || fetch_orig_buffer_flag ||fetch_orig_buffer_zoom_flag ||fetch_disp_buffer_zoom_flag)
{
if(fetch_disp_buffer_flag)
{
lv_disp_draw_buf_sw(0);
}
else if(fetch_disp_buffer_zoom_flag)
{
if(area->y2 + 1 != LV_VER_RES_MAX)
{
return false;
}
else
{
lv_disp_draw_buf_sw(1);
}
}
fetch_disp_buffer_flag = false;
fetch_orig_buffer_flag = false;
fetch_orig_buffer_zoom_flag = false;
fetch_disp_buffer_zoom_flag = false;
return false;
}
if(exit_disp_flush_flag)
{
return false;
}
return true;
}
void* get_display_buffer1(void)
{
return display_framebuffer1;
}
extern bool display_te_status(void);
extern uint8_t volatile te_sign;
#include <stdio.h>
__RAM_CODE void convert_rgb565_to_bgr565(const uint16_t* rgb565_data, uint16_t* bgr565_data, uint32_t num_pixels) {
for (uint32_t i = 0; i < num_pixels; i++) {
uint16_t pixel = rgb565_data[i];
uint16_t bgr_pixel = ((pixel & 0x001F) << 11) | ((pixel & 0x07E0)) | ((pixel & 0xF800) >> 11);
bgr565_data[i] = bgr_pixel;
}
}
uint32_t last_time=0;
extern void uart_transmit_byte(uint8_t *buf,uint32_t len);
extern uint32_t get_system_dwt_value(void);
static void my_disp_flush(lv_disp_drv_t * disp, const lv_area_t * area, lv_color_t * color_p)
{
static uint32_t flush_last_time=0;
static uint8_t flags=0;
#if 1
//printf("disp:%d\r\n",(get_system_dwt_value()-flush_last_time)/192);
#if BOARD_SEL == BOARD_EVB_FR3092E_RGB
if(area->y1 == 0)
{
while(!te_sign)
{
// vTaskDelay(1);
}
}
uint32_t time1 = get_system_dwt_value();
#if 0
for(int i=area->y1; i<= area->y2; i++) //19ms
{
uint16_t *pColor = &(((uint16_t*)display_framebuffer1)[i*480]);
for(int j=area->x1; j<= area->x2; j++)
{
pColor[j] = rgb565_to_bgr(color_p[(i-area->y1)*(area->x2-area->x1+1)+(j-area->x1)].full);
//pColor[j] =(color_p[(i-area->y1)*(area->x2-area->x1+1)+(j-area->x1)].full);
}
}
#else
memcpy((uint8_t*)display_framebuffer1,(uint8_t*)color_p,(area->x2+1-area->x1)*(area->y2+1-area->y1)*2); //3ms
//convert_rgb565_to_bgr565((uint16_t*)color_p,(uint16_t*)display_framebuffer1,(area->x2+1-area->x1)*(area->y2+1-area->y1));//9ms
uint32_t time2 = get_system_dwt_value();
//printf("time:%d\r\n",(time2-time1)/192);
#endif
//
lv_disp_flush_ready(disp);
//last_time = get_system_dwt_value();
#else
// if(!lv_fetch_disp_buffer_func(area))
// {
// lv_disp_flush_ready(disp);
// return;
// }
while(display_dma_ongoing);
system_prevent_sleep_set(SYSTEM_PREVENT_SLEEP_DISPLAY_ONGOING);
display_dma_ongoing = true;
last_disp = disp;
//while(!display_te_status());
display_set_window(area->x1,
area->x2,
area->y1,
area->y2);
#if LV_COLOR_DEPTH == 16
//last_time = get_system_dwt_value();
display_update_dma((area->x2+1-area->x1)*(area->y2+1-area->y1), 16, (void *)color_p);
flush_last_time = get_system_dwt_value();
//display_update((area->x2+1-area->x1)*(area->y2+1-area->y1), 16, (void *)color_p);
lv_disp_flush_ready(disp);
#elif LV_COLOR_DEPTH == 32
display_update_dma((area->x2+1-area->x1)*(area->y2+1-area->y1), 32, (void *)color_p);
#endif
#endif
#else
display_set_window(HOR_OFFSET+area->x1,
HOR_OFFSET+area->x2,
VER_OFFSET+area->y1,
VER_OFFSET+area->y2);
#if LV_COLOR_DEPTH == 16
display_update((area->x2+1-area->x1)*(area->y2+1-area->y1), 16, (void *)color_p);
#elif LV_COLOR_DEPTH == 32
display_update((area->x2+1-area->x1)*(area->y2+1-area->y1), 32, (void *)color_p);
#endif
lv_disp_flush_ready(disp);
#endif
}
static void my_touchpad_read(struct _lv_indev_drv_t * indev, lv_indev_data_t * data)
{
// uint8_t buffer[8];
//
// touchpad_read_data_raw(buffer, 8);
// data->state = (buffer[2] != 0) ? LV_INDEV_STATE_PR : LV_INDEV_STATE_REL;
// if(data->state == LV_INDEV_STATE_PR) {
// data->point.x = ((buffer[3]&0x0f)<<8) | buffer[4];
// data->point.y = ((buffer[5]&0x0f)<<8) | buffer[6];
// }
int16_t x, y;
bool pressed;
pressed = touchpad_read(&x, &y);
if (pressed) {
if ((x < HOR_OFFSET)
|| (x >= HOR_OFFSET + LV_HOR_RES_MAX)
|| (y < VER_OFFSET)
|| (y >= (VER_OFFSET + LV_VER_RES_MAX))) {
data->state = LV_INDEV_STATE_REL;
}
else {
data->state = LV_INDEV_STATE_PR;
data->point.x = x - HOR_OFFSET;
data->point.y = y - VER_OFFSET;
//printf("x:%d,y:%d\n",data->point.x,data->point.y);
}
setup_gui_running();
}
else
{
data->state = LV_INDEV_STATE_REL;
}
}
static uint32_t keypad_get_key(void)
{
/*Your code comes here*/
return key_code;
}
/*Will be called by the library to read the mouse*/
static void keypad_read(lv_indev_drv_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_PR;
/*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;
//printf("keypad_read =================act_key =%d ,last_key %d keydown \r\n",act_key,last_key);
} else {
data->state = LV_INDEV_STATE_REL;
}
data->key = last_key;
}
bool touchpad_state(void)
{
int16_t x, y;
return touchpad_read(&x, &y);
}
lv_group_t *keypad_group; //按键组
static void lvgl_init(void)
{
lv_init();
lv_disp_draw_buf_init(&disp_buf, (void *)display_framebuffer, display_framebuffer1, LV_HOR_RES_MAX * LV_VER_RES_MAX); /*Initialize the display buffer*/
/* Implement and register a function which can copy the rendered image to an area of your display */
static lv_disp_drv_t disp_drv; /*Descriptor of a display driver*/
lv_disp_drv_init(&disp_drv); /*Basic initialization*/
disp_drv.flush_cb = my_disp_flush; /*Set your driver function*/
disp_drv.draw_buf = &disp_buf; /*Assign the buffer to the display*/
disp_drv.hor_res = LV_HOR_RES_MAX;
disp_drv.ver_res = LV_VER_RES_MAX;
disp_drv.physical_hor_res = -1;
disp_drv.physical_ver_res = -1;
disp_drv.offset_x = 0;
disp_drv.offset_y = 0;
disp_drv.full_refresh = 1;
lv_disp_drv_register(&disp_drv); /*Finally register the driver*/
/* Implement and register a function which can read an input device. E.g. for a touch pad */
#if 0
static lv_indev_drv_t indev_drv; /*Descriptor of a input device driver*/
lv_indev_drv_init(&indev_drv); /*Basic initialization*/
indev_drv.type = LV_INDEV_TYPE_POINTER; /*Touch pad is a pointer-like device*/
indev_drv.read_cb = my_touchpad_read; /*Set your driver function*/
lv_indev_drv_register(&indev_drv); /*Finally register the driver*/
#endif
#if 1
/*------------------
* Keypad
* -----------------*/
static lv_indev_drv_t indev_drv1;
/*Initialize your keypad or keyboard if you have*/
/*Register a keypad input device*/
lv_indev_drv_init(&indev_drv1);
indev_drv1.type = LV_INDEV_TYPE_KEYPAD;
indev_drv1.read_cb = keypad_read;
indev_keypad = lv_indev_drv_register(&indev_drv1);
//lv_group_t *keypad_group = NULL; //按键组
keypad_group = lv_group_create();
lv_indev_set_group(indev_keypad, keypad_group);
/*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);`*/
#endif
// lv_demo_benchmark();
// lv_demo_stress();
// lv_demo_widgets();
// lv_demo_music();
//lv_demo_benchmark();
lv_prj_main();
}
//----------------------------------------------------
//end
//----------------------------------------------------
lv_group_t * lv_get_keypad_group(void)
{
return keypad_group;
}
int gui_task_msg_send(uint16_t msg_type,
void *header,
uint16_t header_length,
uint8_t *payload,
uint16_t payload_length,
ipc_tx_callback callback)
{
gui_task_msg_t queue_event;
queue_event.msg_type = msg_type;
queue_event.param_len = header_length+payload_length;
memcpy(queue_event.param, header, header_length);
memcpy(queue_event.param+header_length, payload, payload_length);
//if (portNVIC_INT_CTRL_REG & 0xff)
if(xPortIsInsideInterrupt())
{
BaseType_t xTaskWokenByPost = pdFALSE;
if (xQueueSendFromISR(gui_queue_handle, &queue_event, &xTaskWokenByPost) == errQUEUE_FULL )
{
return -1;
}
else
{
portYIELD_FROM_ISR(xTaskWokenByPost);
}
}
else
{
if (xQueueSend(gui_queue_handle, &queue_event, ( TickType_t ) 0) != pdPASS)
{
return -1;
}
}
return 0;
}
int sync_task_msg_send(uint16_t msg_type,
void *header,
uint16_t header_length,
uint8_t *payload,
uint16_t payload_length,
ipc_tx_callback callback)
{
gui_task_msg_t queue_event;
queue_event.msg_type = msg_type;
queue_event.param_len = header_length+payload_length;
memcpy(queue_event.param, header, header_length);
memcpy(queue_event.param+header_length, payload, payload_length);
//if (portNVIC_INT_CTRL_REG & 0xff)
if(xPortIsInsideInterrupt())
{
BaseType_t xTaskWokenByPost = pdFALSE;
if (xQueueSendFromISR(app_queue_handle, &queue_event, &xTaskWokenByPost) == errQUEUE_FULL )
{
return -1;
}
else
{
portYIELD_FROM_ISR(xTaskWokenByPost);
}
}
else
{
if (xQueueSend(app_queue_handle, &queue_event, ( TickType_t ) 0) != pdPASS)
{
return -1;
}
}
return 0;
}
uint32_t gui_running_last_time;
bool gui_task_resume_flag = false;
bool gui_task_suspend_flag = false;
static void setup_gui_running(void)
{
gui_running_last_time = portGET_RUN_TIME_COUNTER_VALUE();
}
static uint32_t get_gui_running_basetime(void)
{
uint32_t cur_base_time = portGET_RUN_TIME_COUNTER_VALUE();
uint32_t diff;
if(cur_base_time >= gui_running_last_time)
diff = cur_base_time - gui_running_last_time;
else
diff = (((uint32_t)0xFFFFFFFF) - gui_running_last_time) + cur_base_time + 1;
return diff;
}
bool screensaver_lock_flags = false;
static void gui_task_auto_suspend(void)
{
if(get_gui_running_basetime() > (10 * 1000) || gui_task_suspend_flag)
{
lv_obj_add_flag(lv_scr_act(),LV_OBJ_FLAG_HIDDEN);
while(display_dma_ongoing)
{
vTaskDelay(1);
}
setup_gui_running();
display_power_off();
touchpad_sleep();
vTaskSuspend(gui_task_Handle);
gui_task_suspend_flag = false;
}
if(gui_task_resume_flag)
{
gui_task_resume_flag = false;
lv_obj_clear_flag(lv_scr_act(),LV_OBJ_FLAG_HIDDEN);
}
}
bool gui_task_suspend_state(void)
{
return gui_task_suspend_flag;
}
void gui_task_suspend(void)
{
//vTaskSuspend(gui_task_Handle);
gui_task_suspend_flag = true;
}
void * gui_task_handle_is_active(void)
{
return gui_task_Handle;
}
bool gui_task_resume(void)
{
setup_gui_running();
if( eTaskGetState( gui_task_Handle ) == eSuspended)
{
touchpad_init();
display_power_on();
vTaskResume(gui_task_Handle);
gui_task_resume_flag = true;
return true;
}
return false;
}
extern void InitSysDateTime(void);
extern char * GetCurTimeString();
extern void UpdateSysTime();
lv_timer_t * lvgl_main_task_timer;
uint8_t lvgl_start = 0;
//gui task
static void gui_task(void *arg)
{
gui_task_msg_t queue_event;
printf("gui_task \r\n");
/* lfs init */
lfs_custom_init();
//lfs_custom_test_write_file();
//dev_rtc_time_init();
vTaskDelay(200);
lvgl_init();
// Create queue for gui task
gui_queue_handle = xQueueCreate(GUI_TASK_QUEUE_LENGTH, sizeof(gui_task_msg_t));
//battery detect
// adc_vbat_start_detect();
setup_gui_running();
InitSysDateTime();
GetCurTimeString();
lvgl_main_task_timer = lv_timer_create(UpdateSysTime, 1000, NULL);
printf("gui_task run\r\n");
lvgl_start =1;
while(1) {
vTaskDelay(1);
lv_timer_handler();
// rtc_running();
//encode_key_release();
if (xQueueReceive(gui_queue_handle, &queue_event, 0) == pdPASS)
{
gui_task_queue_callback(&queue_event);
}
if(lv_tick_get()%5000==0)
{
printf("lvgl tick\r\n");
}
// gui_task_auto_suspend();
}
}
static void sync_task(void *arg)
{
uint32_t sync_counter = 0;
gui_task_msg_t queue_event;
printf("sync_task \r\n");
// Create queue for sync task
app_queue_handle = xQueueCreate(SYS_TASK_QUEUE_LENGTH, sizeof(gui_task_msg_t));
while(1) {
if (xQueueReceive(app_queue_handle, &queue_event, 0) == pdPASS)
{
}
}
}
void app_lvgl_init(void)
{
memset((uint8_t*)display_framebuffer1,0xff,480*272*2);
#if (BOARD_SEL == BOARD_EVB_FR3092E_RGB)
display_init();
#else
hw_display_init(false);
// hw_touchpad_init(false);
#endif
#if ENABLE_PSRAM
hw_psram_init(false);
printf("PSRAM ID is 0x%08x.\r\n", psram_read_id());
#endif
/* create gui relative task. */
xTaskCreate( gui_task, "gui_task", GUI_TASK_STACK_SIZE, NULL, GUI_TASK_PRIORITY, &gui_task_Handle );
//xTaskCreate( sync_task, "sync_task", SYNC_TASK_STACK_SIZE, NULL, SYNC_TASK_PRIORITY, NULL );
}
//void dma1_irq(void)
//{
// printf("dma1_irq\r\n");
// if (dma_get_tfr_Status(&dma_display_handle)) {
// display_update_dma_isr();
//
// display_dma_ongoing = false;
// my_disp_flush_done();
// system_prevent_sleep_clear(SYSTEM_PREVENT_SLEEP_DISPLAY_ONGOING);
// }
//}
void dma1_irq(void)
{
//printf("dma t:%d\r\n",(get_system_dwt_value()-last_time)/192);
//printf("dma1_irq\r\n");
if (dma_get_tfr_Status(&dma_display_handle)) {
display_update_dma_isr();
display_dma_ongoing = false;
my_disp_flush_done();
system_prevent_sleep_clear(SYSTEM_PREVENT_SLEEP_DISPLAY_ONGOING);
}
}
void gpiob_irq(void)
{
printf("this is gpiob irq\r\n");
// if(exti_get_LineStatus(GPIOB,0xFFFF))
// {
// exti_clear_LineStatus(GPIOB,0xFFFF);
// }
if(exti_get_LineStatus(GPIOB,EXTI_LINE_14))
{
exti_clear_LineStatus(GPIOB,EXTI_LINE_14);
//printf("this is portb exti line 14 \r\n");
// int16_t x, y;
// touchpad_read(&x, &y);
// printf("tp x:%d,y%d\n",x,y)
}
}
uint32_t *user_get_display_framebuffer(void)
{
memset((void*)display_framebuffer1,0,DISPLAY_BUFFER_SIZE);
return (uint32_t *)display_framebuffer1;
}
Reference in New Issue View Git Blame Copy Permalink