debug 无法进入main

发布于 2024-07-13 12:34:06 浏览：525 订阅该版

我给系统中加入了 lvgl

直接出现死机

使用debug调试 也会出现 无法进入main的情况

debug时 会卡在下面的地方：
```
__Vectors_Size  EQU  __Vectors_End - __Vectors

AREA    |.text|, CODE, READONLY

; Reset handler
Reset_Handler    PROC
                 EXPORT  Reset_Handler             [WEAK]
        IMPORT  SystemInit
        IMPORT  __main

LDR     R0, =SystemInit
                 BLX     R0
                 LDR     R0, =__main
                 BX      R0  //在启动代码中会卡在这里
                 ENDP
```

![screenshot_图片.png](https://oss-club.rt-thread.org/uploads/20240713/b8da2868ce10b8dac87e7cada11a559f.png.webp)
这是什么原因呢？  这连调试都没法进行了
我现在的代码是 把初始化代码

任务代码如下， 实际上开机并没有直接运行任务代码，因为也会出现卡死， 为了调试， 把开机启动lvgl取消了，准备先启动起来 在运行lvgl，但是还是不行：

```c
 #include <stdio.h>
#include <rtthread.h>
#include "gpio.h"
// #include "lcd.h"
#include "st7789_lcd.h"
#include "lvgl.h"
#include "lv_port_disp_template.h"
#include "lv_port_indev_template.h"
// GUI Guider Includes
#include "events_init.h"
#include "gui_guider.h"
#include "custom.h"
//#include "SEGGER_SYSVIEW.h"
//#include "SEGGER_RTT.h"

/* Definitions for tasks */

/* Task handles */
#define DEFAULT_TASK_STACK_SIZE 512
static struct rt_thread default_task;
static rt_uint8_t default_task_stack[DEFAULT_TASK_STACK_SIZE];

static rt_thread_t default_task_handle = RT_NULL;

#define LVGL_TASK_STACK_SIZE 40*1024
static struct rt_thread lvgl_task;
static rt_thread_t lvgl_task_handle = RT_NULL;
// static rt_uint8_t lvgl_task_stack[LVGL_TASK_STACK_SIZE];

/* Function prototypes */
static void default_task_entry(void *parameter);
static void lvgl_task_entry(void *parameter);

/* LVGL specific variables */
lv_ui guider_ui;
extern lv_indev_t *indev_encoder;
extern volatile int32_t encoder_diff;
extern volatile unsigned char encoder_button_val;
extern volatile lv_indev_state_t encoder_state;

void lvgl_timer_cb1(lv_timer_t * timer);

/* RT-Thread tick hook function */
static void lvgl_tick_hook(void)
{
    // lv_tick_inc(1);
}

// /* Application initialization function */
// int application_init(void)
// {
//     // // Create the default task
//     // default_task_handle = rt_thread_create("default_task",
//     //                                        default_task_entry,
//     //                                        RT_NULL,
//     //                                        DEFAULT_TASK_STACK_SIZE,
//     //                                        10,
//     //                                        10);
//     // if (default_task_handle != RT_NULL)
//     // {
//     //     rt_thread_startup(default_task_handle);
//     // }

//     // Create the LVGL task
    
//     rt_thread_init(&lvgl_task_handle,
//                     "lvgl_task",
// 										RT_NULL,
//                     lvgl_task_entry,
//                     lvgl_task_stack,
//                     LVGL_TASK_STACK_SIZE,
//                     12,
//                     10);

//     // if (lvgl_task_handle != RT_NULL)
//     // {
//     //     rt_thread_startup(lvgl_task_handle);
//     // }

//     // // Set RT-Thread tick hook to LVGL tick function
//     // rt_thread_idle_sethook(lvgl_tick_hook);

//     return 0;
// }
// INIT_APP_EXPORT(application_init);

int default_task_creat(void)
{
    // Create the default task
    default_task_handle = rt_thread_create("default_task",
                                        default_task_entry,
                                        RT_NULL,
                                        DEFAULT_TASK_STACK_SIZE,
                                        10,
                                        10);
    if (default_task_handle != RT_NULL)
    {
        rt_thread_startup(default_task_handle);
    }
}
MSH_CMD_EXPORT(default_task_creat,default_task_creat);

int default_task_init(void)
{
    // Initialize the default task
    rt_err_t result = rt_thread_init(&default_task,      // Thread control block
                                     "default_task",     // Thread name
                                     default_task_entry, // Thread entry function
                                     RT_NULL,            // Parameter
                                     default_task_stack, // Stack start address
                                     DEFAULT_TASK_STACK_SIZE, // Stack size
                                     14,                 // Thread priority
                                     10);                // Tick

if (result == RT_EOK)
    {
        // Start the thread
        rt_thread_startup(&default_task);
    }
    else
    {
        rt_kprintf("Failed to initialize default task: %d\n", result);
    }
    return 1;
}

#if 0
int GUI_init(void)
{
    rt_kprintf("Starting application_init...\n");
    
    // Create the LVGL task
    rt_err_t result = rt_thread_init(
                                     &lvgl_task,
                                     "lvgl_task",
                                     lvgl_task_entry,
                                     RT_NULL,
                                     lvgl_task_stack,
                                     LVGL_TASK_STACK_SIZE,
                                     10,
                                     10);

if (result == RT_EOK)
    {
        rt_kprintf("LVGL task created successfully.\n");
        rt_thread_startup(&lvgl_task);
    }
    else
    {
        rt_kprintf("Failed to Init LVGL task.\n");
    }

return 1;
}

#endif

int GUI_creat(void)
{

lvgl_task_handle =rt_thread_create( 
                                        "lvgl_task",
                                        lvgl_task_entry,
                                        RT_NULL,
                                        LVGL_TASK_STACK_SIZE,
                                        12,
                                        10);

if (lvgl_task_handle != RT_NULL)
    {
        rt_thread_startup(lvgl_task_handle);
    }
    else
    {
        rt_kprintf("Failed to create LVGL task.\n");
    }
}
// INIT_APP_EXPORT(GUI_create);
// INIT_APP_EXPORT(application_init);
MSH_CMD_EXPORT(GUI_creat,GUI_creat);

static void default_task_entry(void *parameter)
{
    while (1)
    {
        // 按键任务
        //Key_Scanf();
        // page_logic();
        rt_kprintf("Default task running...\n");
        rt_thread_mdelay(1000);
    }
}

static void lvgl_task_entry(void *parameter)
{
    rt_thread_mdelay(10);

// LVGL initialization
    lv_init();
    lv_port_disp_init();
    //lv_port_indev_init();
    // MD_REncoder_Init(&encoder, &encoder_diff, &encoder_button_val, INPUT_MODE_ENCODER, GPIO_MODE_INPUT_PULLUP, GPIOA, GPIO_PIN_0, GPIOA, GPIO_PIN_1, GPIOB, GPIO_PIN_0);

// Create a GUI-Guider app
    setup_ui(&guider_ui);//

// Create a timer, switching pages every 3 seconds
    //lv_timer_create(lvgl_timer_cb1, 3000, RT_NULL);

while (1)
    {
        lv_task_handler();//
        rt_thread_mdelay(10);
    }
}

void lvgl_timer_cb1(lv_timer_t * timer)
{
  printf("Timer expired!\n");
}
```