lv_scr_act();

lv_disp_get_scr_act();

lv_obj_set_user_data();

lv_obj_get_user_data();

lv_obj_del();

lv_obj_clean(); // delete obj children except his bensheng 

lv_obj_set_top(); // 被点击后成为前台显示

lv_obj_move_foreground(); //手动置于前台

lv_obj_move_background(); //手动置于后台

lv_obj_set_parent(obj, new_parent); //obj将位于new_parent的前台

/* 创建一个父对象为 lv_layer_top 的按钮 */

*lv_obj_t* *btn3 = lv_btn_create(lv_layer_top(),NULL);

*lv_obj_t* *slider1 = lv_slider_create(scr, NULL); /* 创建一个 slider 滑动控件 */

lv_obj_set_event_cb(slider1, my_event_cb); /* 为控件设置事件的回调函数 */

case LV_EVENT_PRESSED:

printf("pressed value:%d\n", lv_slider_get_value(obj));

// 以下事件需要使能拖动后才会被触发 

lv_obj_set_drag(obj,true);

lv_obj_set_drag_throw(obj,true); // 惯性

// 以在回调函数中使用 lv_event_get_data() 函数获取自定义数
lv_event_get_data();

//矩阵按钮
*lv_obj_t* *btnm1 = lv_btnm_create(scr,NULL);

//要将事件发送到对象，可以使用 
/*嵌入式设备中，我们往往可以 RTOS 获取按钮的数据然后以事件的方式发送
LittlevGL。也可以在一个对象的事件回调函数中发事件消息到另一个对象*/
lv_event_send(*lv_obj_t* * obj, *lv_event_t* event, const *void* * data)

body.border.opa//：边框不透明度（0-255）
padding//:填充
body.padding.inner//:内部填充（在内容元素或子元素之间）
text.letter_space//:字母之间的间隔
image.intense//:重新着色的不透明度（0 表示不重新着色）
    
lv_label_set_style(label1,LV_LABEL_STYLE_MAIN,&lv_style_transp);

//如果控件有多种状态，例如 btn，可以对不同状态设置不同的样式

lv_btn_set_style(btn,LV_BTN_STYLE_PR,&lv_style_transp); /* 设置 btn 释放时的样式 */

lv_btn_set_style(btn,LV_BTN_STYLE_REL,&lv_style_btn_rel); /* 设置 btn 按下时的样式 */

static *lv_style_t* style_cn_24; /* 定义一个新的样式,注意使用 static */

lv_style_copy(&style_cn_24, &lv_style_pretty_color); /* 复制 style 的属性 */

style_cn_24.text.font = &gb2312_puhui24; /* 重新设置 style 的字体 */

style_cn_24.text.color = LV_COLOR_BLUE; /* 重新设置 style 的文字颜色 */


*lv_obj_t* *label4 = lv_label_create(scr,NULL); /* 创建 label 控件 */

lv_obj_set_style(label4,&style_cn_24); /* 为控件设置新的 style */

lv_obj_set_pos(label4,0,100); /* 设置控件的坐标 */

lv_label_set_text(label4,"这是一个蓝色的中文字体的 label 控件"); /* 设置文字 */

/* 创建主题 */
*lv_theme_t* *theme1 = lv_theme_alien_init(10, NULL);

*lv_theme_t* *theme2 = lv_theme_night_init(10, NULL);

/* 创建按钮并设置主题 */
*lv_obj_t* *btn1 = lv_btn_create(scr, NULL);

*lv_obj_t* *label_btn1 = lv_label_create(btn1,NULL);

lv_label_set_text(label_btn1,"theme_alien");

lv_obj_set_pos(btn1, 10, 10);

lv_btn_set_style(btn1, LV_BTN_STYLE_REL,theme1->style.btn.rel);

lv_btn_set_style(btn1, LV_BTN_STYLE_PR, theme1->style.btn.pr);

/*以上方法需要为每个控件设置主题，如果我们的应用或者某一部分控件使
用同样的主题时，可以定义当前的主题，这样后面再创建控件的时候默认使用
这个主题，例如：*/

/* 创建主题 */

*lv_theme_t* *theme1 = lv_theme_alien_init(10, NULL);

/* 设置当前主题 */

/* 需要在 lv_conf.h 中开启 LV_THEME_LIVE_UPDATE 宏定义以实现实时刷新。*/

lv_theme_set_current(theme1);

/* 创建一个新字体的 style */
static *lv_style_t* style2;

lv_style_copy(&style2, &lv_style_plain);

style2.text.font = &gb2312_puhui32;

/*字体具有 bpp（每像素位数）属性，他表示用于描述字体中像素的位数，b
pp 越高，字体就会越平滑，抗锯齿的效果就会越好，高性能的显示带来的就是
字库的存储空间变大。*/

//符号字体可以直接使用
lv_label_set_text(label,LV_SYMBOL_AUDIO);
//也可以配合字符串一起使用
lv_label_set_text(label,LV_SYMBOL_AUDIO "AUDIO");
//或者两个符号一起使用
lv_label_set_text(label,LV_SYMBOL_AUDIO LV_SYMBOL_BELL);

lv_img_dsc_t 
{
    cf; //图像格式
    always_zero; //始终为 0
    reserver; //保留
    w; //图像宽度 <=2048
    h; //图像高度 <=2048
    data_size; //数据长度
    data; //图像数据的指针
};

// 内部数组或flash中
LV_IMG_DECLARE(tupian) /* 声明一个全局图像变量 */
...
lv_obj_t *img1 = lv_img_create(scr, NULL); /* 创建 img 控件 */
lv_img_set_src(img1, &tupian); /* 设置 img 的数据 */
lv_obj_align(img1, NULL, LV_ALIGN_IN_TOP_MID, 0, 0); /* 设置位置 */

// 如果实现了文件系统接口并且把图像以 bin 文件格式存储在了外部，则应该使用这种方式显示图像：
lv_img_set_src(img1, "P:/lv_examples/tiaotu.bin");

lv_fs_drv_t my_fs_drv; /* 定义一个文件驱动 */
lv_fs_drv_init(&my_fs_drv); /* 初始化 */
my_fs_drv.letter = 'S'; /* 驱动器标识 */
my_fs_drv.file_size = sizeof(my_file_obj); /* 文件对象大小 */
my_fs_drv.file_size = sizeof(my_dir_obj); /* 目录对象大小 */
my_fs_drv.ready_cb = my_fs_ready_cb; /* 文件是否准备就绪 */
my_fs_drv.open_cb = my_fs_open_cb_cb; /* 打开文件 */
my_fs_drv.close_cb = my_fs_close_cb; /* 关闭文件 */
my_fs_drv.remove_cb = my_fs_remove_cb; /* 删除文件 */
my_fs_drv.read_cb = my_fs_read_cb; /* 读取文件 */
my_fs_drv.write_cb = my_fs_write_cb; /* 写入文件 */
my_fs_drv.seek_cb = my_fs_seek_cb; /* 移动读写指针 */
my_fs_drv.tell_cb = my_fs_tell_cb; /* 汇报读写指针位置 */
my_fs_drv.trunc_cb = my_fs_trunc_cb; /* 从读写指针处删除文件 */
my_fs_drv.size_cb = my_fs_size_cb; /* 获取文件大小 */
my_fs_drv.rename_cb = my_fs_rename_cb; /* 重命名文件 */
my_fs_drv.free_space_cb = my_fs_free_space_cb; /* 获取可用空间 */
my_fs_drv.dir_open_cb = my_fs_dir_open_cb; /* 打开目录 */
my_fs_drv.dir_read_cb = my_fs_dir_read_cb; /* 读取目录 */
my_fs_drv.dir_close_cb = my_fs_dir_close_cb; /* 离开目录 */
my_fs_drv.user_data = my_fs_user_data; /* 用户数据 */
lv_fs_drv_register(&pcfs_drv); /* 注册一个文件驱动 */

lv_task_create(task_cb, period, LV_TASK_PRIO_OFF/LOWEST/LOW/MID/HIGH/HIGHEST, user_data);
lv_task_ready(task);
lv_task_reset(task);
lv_task_once(task);

// 仅测量lvgl任务的空闲
lv_task_get_idle(); 
// 异步执行
lv_async_call(func,data_p);

//第一步 引入字体定义
/* 引入字体,等同于 extern */
LV_FONT_DECLARE(font1)
    
//第二步 定义一个带有中文字体的样式
static lv_style_t style_cn; /* 定义新的样式,请注意使用 static 或者全局变量 */
lv_style_copy(&style_cn, &lv_style_pretty_color); /* 复制 style 的属性 */
style_cn.text.font = &font1; /* 设置新字体 */
style_cn.text.color = LV_COLOR_BLACK; /* 设置文字颜色 */

//第三步 创建一个 label 控件并设置中文样式
lv_obj_t *label1 = lv_label_create(scr,NULL); /* 创建 label 控件 */
lv_obj_set_style(label1,&style_cn); /* 为控件设置新的 style */
lv_obj_set_pos(label1,0,0); /* 设置控件的坐标 */
lv_label_set_text(label1,"你好世界"); /* 设置文字 */
lv_obj_align(label1,NULL,LV_ALIGN_IN_TOP_MID,0,100); /* 设置控件的对齐方式-相对坐标 */

lv_obj_set_x(obj, new_x); //设置对象的 X 轴坐标
lv_obj_set_y(obj, new_y); //设置对象的 Y 轴坐标
lv_obj_set_pos(obj, new_x, new_y);//设置对象的坐标

lv_obj_align(obj, base, LV_ALIGN_..., x_mod, y_mod); //base 是参考对象，如果为NULL，就是用父对象
lv_obj_align_origo();//以对象的原点对齐

lv_layer_top() ; lv_layer_sys(); // 可以获取顶层和系统层。
lv_obj_move_foreground(obj); // 可以将对置于前景
lv_obj_move_background(obj); //将对象置于背景

lv_obj_refresh_style(obj); //以使用的样式修改后刷新，已对使用了该样式的obj刷新
lv_obj_report_style_mod(&style) //如果函数的参数为 NULL，则会通知所有对象。

//获取对象实际可用区域
void lv_obj_get_inner_coords(const lv_obj_t * obj, lv_area_t * coords_p);
//获取发送事件到父对象的属性
bool lv_obj_get_parent_event(const lv_obj_t * obj);
// 获取对象扩展数据 void * ext_attr;            /**< Object type specific extended data*/
void * lv_obj_get_ext_attr(const lv_obj_t * obj);

//获取对象及其父级对象的类型
//其他说明：从当前类型开始，将其名称放入`type_buf`中。例如 buf.type [0]
//=“ lv_btn”，buf.type [1] =“ lv_cont”，buf.type [2] =“ lv_obj”
void lv_obj_get_type(lv_obj_t * obj, lv_obj_type_t * buf);

//判断对象是否是组的聚焦对象
//true：对象已聚焦
//false：对象未聚焦或不在组中
bool lv_obj_is_focused(const lv_obj_t * obj);

lv_label_set_text(label,"New text") //lv库分配内存
lv_label_set_static_text(label,char_array) //用户分配内存
lv_label_set_array_text(label4, char_array,num)//用户使用数组，不必是‘/0’结尾

void lv_label_set_align(lv_obj_t * label, lv_label_align_t align);
void lv_obj_align(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs, lv_coord_t y_ofs);
lv_label_set_body_draw(label,en); //允许设置label的背景
//设置 label 选择开始索引
void lv_label_set_text_sel_start/end(lv_obj_t * label, uint16_t index);
//获取 label 某个字符的相对坐标
void lv_label_get_letter_pos(const lv_obj_t * label, uint16_t index, lv_point_t * pos);
//在 label 上追加文本
void lv_label_ins_text(lv_obj_t * label, uint32_t pos, const char *txt);
//从 label 中删除字符
void lv_label_cut_text(lv_obj_t * label, uint32_t pos, uint32_t cnt);

LV_LAYOUT_OFF //没有布局
LV_LAYOUT_CENTER //中心对齐
LV_LAYOUT_COL_L //列左对齐
LV_LAYOUT_COL_M //列中间对齐
LV_LAYOUT_COL_R //列右对齐
LV_LAYOUT_ROW_T //行顶部对齐
LV_LAYOUT_ROW_M //行中间对齐
LV_LAYOUT_ROW_B //行底部对齐
LV_LAYOUT_PRETTY //将尽可能多的对象放在行中并开始新
LV_LAYOUT_GRID //将相同大小的对象对齐到网格中
  
/*
LV_FIT_NONE //不自动更改大小
LV_FIT_TIGHT //收缩到子对象大小
LV_FIT_FLOOD //将尺寸与父对象的边缘对齐
LV_FIT_FILL //与父对象边缘对齐
*/
lv_btn_set_fit/fit2/fit4(btn,LV_FIT_..);

//其他宏定义，这些宏定义用于根据颜色格式和尺寸计算缓冲区大小
#define LV_CANVAS_BUF_SIZE_TRUE_COLOR(w, h) ((LV_COLOR_SIZE / 8) * w * h)
#define LV_CANVAS_BUF_SIZE_TRUE_COLOR_CHROMA_KEYED(w, h) ((LV_COLOR_SIZE / 8) * w * h)
#define LV_CANVAS_BUF_SIZE_TRUE_COLOR_ALPHA(w, h) (LV_IMG_PX_SIZE_ALPHA_BYTE * w * h)
/*+ 1: to be sure no fractional row*/
#define LV_CANVAS_BUF_SIZE_ALPHA_1BIT(w, h) ((((w / 8) + 1) * h))
#define LV_CANVAS_BUF_SIZE_ALPHA_2BIT(w, h) ((((w / 4) + 1) * h))
#define LV_CANVAS_BUF_SIZE_ALPHA_4BIT(w, h) ((((w / 2) + 1) * h))
#define LV_CANVAS_BUF_SIZE_ALPHA_8BIT(w, h) ((w * h))
/*4 * X: for palette*/
#define LV_CANVAS_BUF_SIZE_INDEXED_1BIT(w, h) (LV_CANVAS_BUF_SIZE_ALPHA_1BIT(w, h) + 4 * 2)
#define LV_CANVAS_BUF_SIZE_INDEXED_2BIT(w, h) (LV_CANVAS_BUF_SIZE_ALPHA_2BIT(w, h) + 4 * 4)
#define LV_CANVAS_BUF_SIZE_INDEXED_4BIT(w, h) (LV_CANVAS_BUF_SIZE_ALPHA_4BIT(w, h) + 4 * 16)
#define LV_CANVAS_BUF_SIZE_INDEXED_8BIT(w, h) (LV_CANVAS_BUF_SIZE_ALPHA_8BIT(w, h) + 4 * 256)

void rt_hw_board_init(void)
{
....
#ifdef RT_USING_HEAP
    rt_system_heap_init((void *)NRF_HEAP_BEGIN, (void *)CHIP_HEAP_END); // 系统堆初始化
    rt_kprintf("beagin:0x%x\r\n", NRF_HEAP_BEGIN);
#endif

#ifdef RT_USING_COMPONENTS_INIT
    rt_components_board_init();  // MCU外设硬件初始化
#endif

#if defined(RT_USING_CONSOLE) && defined(RT_USING_DEVICE)
    rt_console_set_device(RT_CONSOLE_DEVICE_NAME);
#endif
....
}

/**
 * RT-Thread Components Initialization for board
 */
void rt_components_board_init(void)
{
    volatile const init_fn_t *fn_ptr;

    for (fn_ptr = &__rt_init_rti_board_start; fn_ptr <= &__rt_init_rti_board_end; fn_ptr++)
    {
        (*fn_ptr)();
    }
}

/**
 * RT-Thread Components Initialization
 */
void rt_components_init(void)
{
    volatile const init_fn_t *fn_ptr;
    rt_kprintf("__rt_init_rti_board_end:0x%x __rt_init_rti_end: 0x%x\n", &__rt_init_rti_board_end,&__rt_init_rti_end);
    for (fn_ptr = &__rt_init_rti_board_end; fn_ptr <= &__rt_init_rti_end; fn_ptr ++)
    {
        (*fn_ptr)();
    }
}

// 初始化一个静态的内核对象，要求对象已经存在空间
void rt_object_init(struct rt_object         *object,
                    enum rt_object_class_type type,
                    const char               *name);
// 脱离一个静态对象，把它从内核链表中移除，空间并不会被释放因为是静态对象
void rt_object_detach(rt_object_t object);

// 分配一个对象，返回一个指向该对象的指针
rt_object_t rt_object_allocate(enum rt_object_class_type type, const char *name);
// 删除一个对象
void rt_object_delete(rt_object_t object);

// 判断一个对象是静态对象还是动态对象
rt_bool_t rt_object_is_systemobject(rt_object_t object);

#define RT_WEAK                     __attribute__((weak))
#define rt_inline                   static __inline
#define RT_UNUSED                   __attribute__((unused))
#define RT_USED                     __attribute__((used))
#define PRAGMA(x)                   _Pragma(#x)
#define ALIGN(n)                    __attribute__((aligned(n)))
#define RT_ALIGN(size, align)           (((size) + (align) - 1) & ~((align) - 1))

// 硬件定时器初始化：初始化硬件定时器链表
void rt_system_timer_init(void);

// 软件定时器初始化：初始化软件定时器链表和创建软件定时器线程
void rt_system_timer_thread_init(void)；

void rt_enter_critical(void); // 锁调度器方式，防止线程调度
void rt_exit_critical(void);

void rt_hw_interrupt_enable(rt_base_t level); // 屏蔽中断方式
rt_base_t rt_hw_interrupt_disable(void);

// 缓存区信息结构体
struct msg
{
    char *pdata; // 指向缓存区
    int data_size; // 缓冲区的长度
};


struct msg *msg_ptr = (struct msg *)malloc(sizeof(struct msg));
msg_ptr->pdata = ...;
msg_ptr->data_size = ...;

struct rt_messagequeue
{
    struct rt_ipc_object parent;

    void* msg_pool;                     /* 指向存放消息的缓冲区的指针 */

    rt_uint16_t msg_size;               /* 每个消息的长度 */
    rt_uint16_t max_msgs;               /* 最大能够容纳的消息数 */

    rt_uint16_t entry;                  /* 队列中已有的消息数 */

    void* msg_queue_head;               /* 消息链表头 */
    void* msg_queue_tail;               /* 消息链表尾 */
    void* msg_queue_free;               /* 空闲消息链表 */

    rt_list_t suspend_sender_thread;    /* 发送线程的挂起等待队列 */
};
typedef struct rt_messagequeue* rt_mq_t;

struct rt_mq_message
{
    struct rt_mq_message *next;  // 消息体指针
};

rt_err_t rt_mq_recv(rt_mq_t    mq,
                    void      *buffer,
                    rt_size_t  size,  // 最大不能大于每条消息的最大长度msg_size
                    rt_int32_t timeout);

struct msg
{
    /* 消息内容 */
    ....
    struct rt_mailbox ack; // 消息中带有一个邮箱，让接收者接收到这条消息后会一个邮件，发送者发送完消息后要阻塞等待接收者回的邮件（状态码）
}

struct rt_thread
{
    #if defined(RT_USING_SIGNALS)
    rt_sigset_t     sig_pending;                        /**< the pending signals */
    rt_sigset_t     sig_mask;                           /**< the mask bits of signal */

#ifndef RT_USING_SMP
    void            *sig_ret;                           /**< the return stack pointer from signal */
#endif
    rt_sighandler_t *sig_vectors;                       /**< 信号执行函数表 */
    void            *si_list;                           /**< the signal infor list */
#endif
};

rt_sighandler_t rt_signal_install(int signo, rt_sighandler_t handler)； // 安装信号，在线程给信号绑定一个回调函数

void rt_signal_mask(int signo);  // 信号阻塞：相当于屏蔽信号，信号将不会窗体给安装次信号的线程

void rt_signal_unmask(int signo);  // 解除信号阻塞：使线程结束到该信号后有效

// set: 指定等待的信号
// si：指向储存等到信号信息的指针
// timeout：等待时间
int rt_signal_wait(const rt_sigset_t *set, rt_siginfo_t *si, rt_int32_t timeout);

// __CC_ARM编译器（kile）， ZI 段结尾处表示
extern int Image$$RW_IRAM1$$ZI$$Limit;
#define HEAP_BEGIN      ((void *)&Image$$RW_IRAM1$$ZI$$Limit)

// IAR_ARM编译器，ZI 段结尾处表示
extern int __bss_end__;
#define HEAP_BEGIN   (&__bss_end__)

#define HEAP_MAGIC 0x1ea0
struct heap_mem
{
    /* magic and used flag */
    rt_uint16_t magic;
    rt_uint16_t used;
    rt_size_t next, prev;
    rt_uint8_t thread[4];   /* thread name */
};

/** pointer to the heap: for alignment, heap_ptr is now a pointer instead of an array */
static rt_uint8_t *heap_ptr;

/** the last entry, always unused! */
static struct heap_mem *heap_end;

rt_mp_t rt_mp_create(const char *name,
                     rt_size_t   block_count,
                     rt_size_t   block_size);
rt_err_t rt_mp_delete(rt_mp_t mp);
void *rt_mp_alloc(rt_mp_t mp, rt_int32_t time);
void rt_mp_free(void *block);

void rt_interrupt_enter(void)  // 通知内核进入中断状态,把全局变量 rt_interrupt_nest 加 1
{
    rt_base_t level;

    level = rt_hw_interrupt_disable();
    rt_interrupt_nest ++;
    rt_hw_interrupt_enable(level);
}

void rt_interrupt_leave(void) // 通知内核离开中断状态,将全局变量 rt_interrupt_nest 减 1
{
    rt_base_t level;

    level = rt_hw_interrupt_disable();
    rt_interrupt_nest --;
    rt_hw_interrupt_enable(level);
}

rt_base_t rt_hw_interrupt_disable(void); // 关中断
void rt_hw_interrupt_enable(rt_base_t level); // 开中断

/* 关闭中断 */
level = rt_hw_interrupt_disable();
a = a + value;
/* 恢复中断 */
rt_hw_interrupt_enable(level);复制错误复制成功

/* 获得信号量锁 */
rt_sem_take(sem_lock, RT_WAITING_FOREVER);
a = a + value;
/* 释放信号量锁 */
rt_sem_release(sem_lock);复制错误复制成功

#include <rthw.h>

void global_interrupt_demo(void)
{
    rt_base_t level0;
    rt_base_t level1;

    /* 第一次关闭全局中断，关闭之前的全局中断状态可能是打开的，也可能是关闭的 */
    level0 = rt_hw_interrupt_disable();
    /* 第二次关闭全局中断，关闭之前的全局中断是关闭的，关闭之后全局中断还是关闭的 */
    level1 = rt_hw_interrupt_disable();

    do_something();

    /* 恢复全局中断到第二次关闭之前的状态，所以本次 enable 之后全局中断还是关闭的 */
    rt_hw_interrupt_enable(level1);
    /* 恢复全局中断到第一次关闭之前的状态，这时候的全局中断状态可能是打开的，也可能是关闭的 */
    rt_hw_interrupt_enable(level0);
}

void rt_interrupt_enter(void);  // rt_interrupt_nest++
void rt_interrupt_leave(void);  // rt_interrupt_nest--

/* 轮询模式向串口写入数据 */
    while (size)
    {
        /* 判断 UART 外设中数据是否发送完毕 */
        while (!(uart->uart_device->SR & USART_FLAG_TXE));
        /* 当所有数据发送完毕后，才发送下一个数据 */
        uart->uart_device->DR = (*ptr & 0x1FF);

        ++ptr; --size;
    }复制错误复制成功

/************** context_rvds.S 实现 ***************/
// 关全局中断
rt_base_t rt_hw_interrupt_disable();
// 开全局中断
void rt_hw_interrupt_enable(rt_base_t level);
// 从from线程切换到to线程
void rt_hw_context_switch(rt_uint32 from, rt_uint32 to);
// 第一次线程切换，没有from线程
void rt_hw_context_switch_to(rt_uint32 to);
{
    	.....
        LDR     r0, =NVIC_INT_CTRL              ; 触发PendSV异常
        .....
}
// 中断中从from线程切换到to线程
void rt_hw_context_switch_interrupt(rt_uint32 from, rt_uint32 to);
// pendsv中断服务函数
void PendSV_Handler(void)


/************** cpuport.c 实现 ***************/
// 在线程进行上下文切换时，用来保存from和头线程
rt_uint32_t rt_interrupt_from_thread, rt_interrupt_to_thread;
// 表示需要在中断里进行线程切换的标志
rt_uint32_t rt_thread_switch_interrupt_flag;
    
// 线程栈初始化，内核在线程创建时调用，会手动构建一个上下文内容，作为每个线程第一次执行的初始值   
rt_uint8_t *rt_hw_stack_init(void       *tentry,
                             void       *parameter,
                             rt_uint8_t *stack_addr,
                             void       *texit)

void SysTick_Handler(void)
{
    /* enter interrupt */
    rt_interrupt_enter();

    HAL_IncTick();
    rt_tick_increase(); // 主要对系统时间加加，对当前线程的时间片减减，检查硬件定时器链表是否有定时器时间已到，到了要执行定时器回调函数

    /* leave interrupt */
    rt_interrupt_leave();
}

MSH_CMD_EXPORT(name, desc);

void hello(void)// 不带参数的命令函数定义
{
    rt_printf("hello\n");
}

#ifdef FINSH_USING_MSH
MSH_CMD_EXPORT(hello, say hello);
#endif

void atcmd(int argc, char **argv) // 带参数的命令函数定义
{
    if (argc < 2)
    {
        rt_kprintf("please input 'atcmd <server|client>'\n");
        return; 
    }
    
    if (strcmp(argv[1], "server") == 0)
    { 
        rt_kprintf("AT server\n");
    }
    else if (strcmp(argv[1], "client") == 0)
    { 
        rt_kprintf("AT client\n");
    }
    else
    {
        rt_kprintf("please input 'atcmd <server|client>'\n");
    }
}

#ifdef FINSH_USING_MSH
MSH_CMD_EXPORT(atcmd, atcmd <server|client>);
#endif

FINSH_FUNCTION_EXPORT(name, desc);

/************** device.c *******************/
// 1.通过名字查找设备，返回设备句柄
rt_device_t rt_device_find(const char *name);
// 2.通过设备句柄打开这个设备
rt_err_t rt_device_open(rt_device_t dev, rt_uint16_t oflag);
// 3.通过设备句柄，读设备数据
rt_size_t rt_device_read(rt_device_t dev,
                         rt_off_t    pos,
                         void       *buffer,
                         rt_size_t   size);

rt_size_t rt_device_write(rt_device_t dev,
                          rt_off_t    pos,
                          const void *buffer,
                          rt_size_t   size)
// 4.关闭设备
rt_err_t rt_device_close(rt_device_t dev);

// 驱动程序实例化一个设备对象，并通过此接口注册到IO设备管理层
rt_err_t rt_device_register(rt_device_t dev,
                            const char *name,
                            rt_uint16_t flags);

/*************** serial.c ******************/
// 1.提供给驱动层使用的，注册一个设备到IO管理层
rt_err_t rt_hw_serial_register(struct rt_serial_device *serial,
                               const char              *name,
                               rt_uint32_t              flag,
                               void                    *data)
{
    rt_err_t ret;
    struct rt_device *device; // 待封装的设备对象

    device = &(serial->parent);

    device->type        = RT_Device_Class_Char;
    device->rx_indicate = RT_NULL;
    device->tx_complete = RT_NULL;

    device->ops         = &serial_ops;  

    /* register a character device */
    ret = rt_device_register(device, name, flag); // 注册封装好的设备对象到IO管理层

....
    return ret;
}

struct serial_ops // 设备对象方法
{
    .config = stm32_configure,
    .putc = stm32_putc,
    .getc = stm32_getc
}

/******************** drv_uart.c **************************/
// 初始化串口设备
static rt_err_t stm32_configure(struct rt_serial_device *serial, struct serial_configure *cfg) 
{
.....
    if (HAL_UART_Init(&uart->handle) != HAL_OK)
    {
        return -RT_ERROR;
    }

    return RT_EOK;
}

// 向串口设备写一个字符
static int stm32_putc(struct rt_serial_device *serial, char c) 
{
...
    uart->handle.Instance->DR = c;
    while (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_TC) == RESET);
    return 1;
}

// 从串口设备读一个字符
static int stm32_getc(struct rt_serial_device *serial) 
{
...
    ch = uart->handle.Instance->DR & 0xff;
    return ch;
}

// 注册一个设备到设备框架层，在系统启动时调用，会注册设备到IO管理层，也可以封装成设备对象方法，在应用程序需要的时候调用初始化设备
int rt_hw_usart_init(void)
{
    rt_size_t obj_num = sizeof(uart_obj) / sizeof(struct stm32_uart);
    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
    rt_err_t result = 0;

    stm32_uart_get_dma_config();

    for (int i = 0; i < obj_num; i++)
    {
        /* init UART object */
        uart_obj[i].config = &uart_config[i];
        uart_obj[i].serial.ops    = &stm32_uart_ops;
        uart_obj[i].serial.config = config;

        /* register UART device */
        result = rt_hw_serial_register(&uart_obj[i].serial, uart_obj[i].config->name,
                                       RT_DEVICE_FLAG_RDWR
                                       | RT_DEVICE_FLAG_INT_RX
                                       | RT_DEVICE_FLAG_INT_TX
                                       | uart_obj[i].uart_dma_flag
                                       , NULL);
        RT_ASSERT(result == RT_EOK);
    }

    return result;
}

/******************** shell.c ****************************/
// 通过名字设置一个设备给finsh用
void finsh_set_device(const char *device_name)
{
   ...
    /* open this device and set the new device in finsh shell */
    if (rt_device_open(dev, RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX | \  // 打开一个设备里面会调用设备提供的open函数
                       RT_DEVICE_FLAG_STREAM) == RT_EOK)
    {
        if (shell->device != RT_NULL)
        {
            /* close old finsh device */
            rt_device_close(shell->device);  // 关闭设备里面会调用设备提供的close函数
            rt_device_set_rx_indicate(shell->device, RT_NULL);
        }
    }

     ...
}

// 设备类型
enum rt_device_class_type
{
    RT_Device_Class_Char = 0,                           /**< 字符设备 */
    RT_Device_Class_Block,                              /**< 块设备 */
    RT_Device_Class_NetIf,                              /**< 网络接口设备 */
    RT_Device_Class_MTD,                                /**< 内存设备 */
    RT_Device_Class_CAN,                                /**< can设备 */
    RT_Device_Class_RTC,                                /**< RTC设备 */
    RT_Device_Class_Sound,                              /**< 声音设备 */
    RT_Device_Class_Graphic,                            /**< 图形设备 */
    RT_Device_Class_I2CBUS,                             /**< I2C总线设备 */
    RT_Device_Class_USBDevice,                          /**< USB从设备 */
    RT_Device_Class_USBHost,                            /**< USB主设备 */
    RT_Device_Class_SPIBUS,                             /**< SPI总线 */
    RT_Device_Class_SPIDevice,                          /**< SPI设备 */
    RT_Device_Class_SDIO,                               /**< SDIO总线设备 */
    RT_Device_Class_PM,                                 /**< PM伪设备 */
    RT_Device_Class_Pipe,                               /**< 管道设备 */
    RT_Device_Class_Portal,                             /**< 门户设备 */
    RT_Device_Class_Timer,                              /**< 计时器设备 */
    RT_Device_Class_Miscellaneous,                      /**< 其他设备 */
    RT_Device_Class_Sensor,                             /**< 传感器设备 */
    RT_Device_Class_Touch,                              /**< 触摸设备 */
    RT_Device_Class_PHY,                                /**< 物理设备 */
    RT_Device_Class_Unknown                             /**< 未知设备 */
};

/**
 * 设备对象
 */
struct rt_device
{
    struct rt_object          parent;                   /**< 内核对象基类 */

    enum rt_device_class_type type;                     /**< 设备类型 */
    rt_uint16_t               flag;                     /**< 设备参数 */
    rt_uint16_t               open_flag;                /**< 设备打开标志 */

    rt_uint8_t                ref_count;                /**< 设备被引用次数 */
    rt_uint8_t                device_id;                /**< 设备id：0 - 255 */

    /* 数据收发回调 */
    rt_err_t (*rx_indicate)(rt_device_t dev, rt_size_t size);
    rt_err_t (*tx_complete)(rt_device_t dev, void *buffer);
    
    const struct rt_device_ops *ops;


    void                     *user_data;                /**< 设备私有数据 */
};
typedef struct rt_device *rt_device_t;

#define RT_DEVICE_FLAG_INT_RX           0x100           /**< INT mode on Rx */
#define RT_DEVICE_FLAG_DMA_RX           0x200           /**< DMA mode on Rx */
#define RT_DEVICE_FLAG_INT_TX           0x400           /**< INT mode on Tx */
#define RT_DEVICE_FLAG_DMA_TX           0x800           /**< DMA mode on Tx */

#define RT_DEVICE_OFLAG_CLOSE           0x000           /**< device is closed */
#define RT_DEVICE_OFLAG_RDONLY          0x001           /**< read only access */
#define RT_DEVICE_OFLAG_WRONLY          0x002           /**< write only access */
#define RT_DEVICE_OFLAG_RDWR            0x003           /**< read and write */
#define RT_DEVICE_OFLAG_OPEN            0x008           /**< device is opened */
#define RT_DEVICE_OFLAG_MASK            0xf0f           /**< mask of open flag */

// 该函数主要执行 dev->open();
rt_err_t rt_device_open(rt_device_t dev, rt_uint16_t oflag);

// 该函数主要执行 dev->control();
rt_err_t rt_device_control(rt_device_t dev, int cmd, void *arg);

/**
 * general device commands
 */
#define RT_DEVICE_CTRL_RESUME           0x01            /**< resume device */
#define RT_DEVICE_CTRL_SUSPEND          0x02            /**< suspend device */
#define RT_DEVICE_CTRL_CONFIG           0x03            /**< configure device */
#define RT_DEVICE_CTRL_CLOSE            0x04            /**< close device */

#define RT_DEVICE_CTRL_SET_INT          0x10            /**< set interrupt */
#define RT_DEVICE_CTRL_CLR_INT          0x11            /**< clear interrupt */
#define RT_DEVICE_CTRL_GET_INT          0x12            /**< get interrupt status */

// pos:根据设备的不同有不同的意义，读串口设备底层会忽略这个参数，pos参数没有一样
rt_size_t rt_device_read(rt_device_t dev,
                         rt_off_t    pos,
                         void       *buffer,
                         rt_size_t   size);
// pos：写入数据在 buffer 的偏移量
rt_size_t rt_device_write(rt_device_t dev,
                          rt_off_t    pos,
                          const void *buffer,
                          rt_size_t   size);

// 设置接收数据回调：设置一个回调函数，当硬件设备接收到数据时，
// 会回调这个函数，并把数据长度放在size中，上层应用线程收到指示后，立刻从设备中读取数据
rt_err_t rt_device_set_rx_indicate(rt_device_t dev,
                          rt_err_t (*rx_ind)(rt_device_t dev, rt_size_t size))
{
    dev->rx_indicate = rx_ind; // 在上层定义，注册到对象里面，底层驱动在条件满足的时候会调用该函数

    return RT_EOK;
}

// 设置发送完数据回调：当硬件设备发送完数据，驱动程序回调这个函数并把发送完成的数据块地址buffer作为参数传递给上层应用，
// 上层应用线程收到指示后会根据buffer的情况，释放buffer内存或将其作为下一个写数据的缓存。
rt_err_t rt_device_set_tx_complete(rt_device_t dev,
                          rt_err_t (*tx_done)(rt_device_t dev, void *buffer))
{
    dev->tx_complete = tx_done; // 在上层定义，注册到对象里面，底层驱动在条件满足的时候会调用该函数

    return RT_EOK;
}

int xxx_writedata(uint8_t* buffer, size_t buff_size)
{
    ....
    device = rt_device_find("spi1");
    if (!device)
    {
        rt_kprintf("find spi1 failed!\n");
        return RT_ERROR;
    }
    err = rt_device_open(device, RT_DEVICE_OFLAG_WRONLY);
    if (err < 0)
    {
        rt_kprintf("open spi1 failed!\n");
        return RT_ERROR;
    }

    rt_device_write(device, 0, (const void *)buffer, buff_size);
    rt_device_close(device);
    ....
}    

struct rt_serial_device
{
    struct rt_device          parent;  /* 设备基类 */

    const struct rt_uart_ops *ops;     /* 串口设备的操作方法，有串口设备驱动提供 */
    struct serial_configure   config;  /* 串口设备配置参数 */

    void *serial_rx;  /* 指向接收数据缓冲区 */
    void *serial_tx;  /* 指向发送数据缓冲区 */
};
typedef struct rt_serial_device rt_serial_t;

// control方法是可以说是多个方法的集合，它根据 cmd 的不同，可以执行不同的操作：比如：开中断、关中断、配置串口dma、配置dma中断等
// arg 可以传入一些配置参数进来，类似指定是配置dma的tx还是rx这样的
static rt_err_t stm32_control(struct rt_serial_device *serial, int cmd, void *arg)
{
    struct stm32_uart *uart;
#ifdef RT_SERIAL_USING_DMA
    rt_ubase_t ctrl_arg = (rt_ubase_t)arg;
#endif

    RT_ASSERT(serial != RT_NULL);
    uart = rt_container_of(serial, struct stm32_uart, serial);

    switch (cmd)
    {
    /* disable interrupt */
    case RT_DEVICE_CTRL_CLR_INT:
        /* disable rx irq */
        NVIC_DisableIRQ(uart->config->irq_type);
        /* disable interrupt */
        __HAL_UART_DISABLE_IT(&(uart->handle), UART_IT_RXNE);

#ifdef RT_SERIAL_USING_DMA
        /* disable DMA */
        if (ctrl_arg == RT_DEVICE_FLAG_DMA_RX)
        {
            HAL_NVIC_DisableIRQ(uart->config->dma_rx->dma_irq);
            if (HAL_DMA_Abort(&(uart->dma_rx.handle)) != HAL_OK)
            {
                RT_ASSERT(0);
            }

            if (HAL_DMA_DeInit(&(uart->dma_rx.handle)) != HAL_OK)
            {
                RT_ASSERT(0);
            }
        }
        else if(ctrl_arg == RT_DEVICE_FLAG_DMA_TX)
        {
            HAL_NVIC_DisableIRQ(uart->config->dma_tx->dma_irq);
            if (HAL_DMA_DeInit(&(uart->dma_tx.handle)) != HAL_OK)
            {
                RT_ASSERT(0);
            }
        }
#endif
        break;

    /* enable interrupt */
    case RT_DEVICE_CTRL_SET_INT:
        /* enable rx irq */
        HAL_NVIC_SetPriority(uart->config->irq_type, 1, 0);
        HAL_NVIC_EnableIRQ(uart->config->irq_type);
        /* enable interrupt */
        __HAL_UART_ENABLE_IT(&(uart->handle), UART_IT_RXNE);
        break;

#ifdef RT_SERIAL_USING_DMA
    case RT_DEVICE_CTRL_CONFIG:
        stm32_dma_config(serial, ctrl_arg);
        break;
#endif

    case RT_DEVICE_CTRL_CLOSE:
        if (HAL_UART_DeInit(&(uart->handle)) != HAL_OK )
        {
            RT_ASSERT(0)
        }
        break;

    }
    return RT_EOK;
}

@startuml
participant 应用程序 order 1
participant IO设备管理器 order 2
participant 串口设备驱动框架 order 3
participant 串口设备驱动 order 4
autonumber "<b>[0]"

串口设备驱动 -[#green]> 串口设备驱动: 创建串口设备
串口设备驱动 -[#blue]> 串口设备驱动框架: 注册串口设备 rt_hw_serial_register()
串口设备驱动框架 -[#blue]> IO设备管理器: 注册I/O设备 rt_device_register()

应用程序 -> IO设备管理器: 查找串口设备 rt_device_find()
应用程序 -> IO设备管理器: 打开串口设备 rt_device_open()
IO设备管理器 -> 串口设备驱动框架: rt_serial_open()
串口设备驱动框架 -> 串口设备驱动: 使能设备 control()
应用程序 -> IO设备管理器: 读串口数据 rt_device_read()
IO设备管理器 -> 串口设备驱动框架: rt_serial_read()
串口设备驱动框架 -> 串口设备驱动: 读取数据 getc()
应用程序 -> IO设备管理器: 关闭串口设备 rt_device_close()
IO设备管理器 -> 串口设备驱动框架: rt_serial_close()
串口设备驱动框架 -> 串口设备驱动: 关闭设备 control()
@enduml

// 驱动注册到驱动框架
rt_err_t rt_hw_serial_register(struct rt_serial_device *serial,
                               const char              *name,
                               rt_uint32_t              flag,
                               void                    *data)
{
    rt_err_t ret;
    struct rt_device *device;
    RT_ASSERT(serial != RT_NULL);

    device = &(serial->parent);

    device->type        = RT_Device_Class_Char;
    device->rx_indicate = RT_NULL;
    device->tx_complete = RT_NULL;

    device->ops         = &serial_ops;
    device->user_data   = data;

    /* register a character device */
    ret = rt_device_register(device, name, flag);  // 需要把device设备挂载到内核对象链表，驱动层没有这个权限，所以需要交给IO设备管理层去做

    return ret;
}

// 驱动框架设备注册到IO设备管理器
rt_err_t rt_device_register(rt_device_t dev,
                            const char *name,
                            rt_uint16_t flags)
{
    if (dev == RT_NULL)
        return -RT_ERROR;

    if (rt_device_find(name) != RT_NULL)
        return -RT_ERROR;

    rt_object_init(&(dev->parent), RT_Object_Class_Device, name);
    dev->flag = flags;
    dev->ref_count = 0;
    dev->open_flag = 0;

    return RT_EOK;
}

#define RT_DEVICE_FLAG_RDONLY           0x001           /**< read only */
#define RT_DEVICE_FLAG_WRONLY           0x002           /**< write only */
#define RT_DEVICE_FLAG_RDWR             0x003           /**< read and write */

#define RT_DEVICE_FLAG_REMOVABLE        0x004           /**< removable device */
#define RT_DEVICE_FLAG_STANDALONE       0x008           /**< standalone device */
#define RT_DEVICE_FLAG_ACTIVATED        0x010           /**< device is activated */
#define RT_DEVICE_FLAG_SUSPENDED        0x020           /**< device is suspended */
#define RT_DEVICE_FLAG_STREAM           0x040           /**< stream mode */

#define RT_DEVICE_FLAG_INT_RX           0x100           /**< INT mode on Rx */
#define RT_DEVICE_FLAG_DMA_RX           0x200           /**< DMA mode on Rx */
#define RT_DEVICE_FLAG_INT_TX           0x400           /**< INT mode on Tx */
#define RT_DEVICE_FLAG_DMA_TX           0x800           /**< DMA mode on Tx */

// 在串口中断中回调
void rt_hw_serial_isr(struct rt_serial_device *serial, int event)
{
    switch (event & 0xff)
    {
        case RT_SERIAL_EVENT_RX_IND:
    .....
            /* invoke callback */
            if (serial->parent.rx_indicate != RT_NULL)
            {
                rt_size_t rx_length;

                /* get rx length */
                level = rt_hw_interrupt_disable();
                rx_length = (rx_fifo->put_index >= rx_fifo->get_index)? (rx_fifo->put_index - rx_fifo->get_index):
                    (serial->config.bufsz - (rx_fifo->get_index - rx_fifo->put_index));
                rt_hw_interrupt_enable(level);

                if (rx_length)
                {
                    serial->parent.rx_indicate(&serial->parent, rx_length); // 串口回调
                }
            }
            break;
        }
            ...
    }

// spi总线对象
struct rt_spi_bus
{
    struct rt_device parent;   /* 设备基类 */
    rt_uint8_t mode;
    const struct rt_spi_ops *ops;  /* SPI总线的操作方法 */

    struct rt_mutex lock;          /* 互斥锁，防止总线上的从设备访问冲突 */
    struct rt_spi_device *owner;  /* SPI总线的持有者SPI从设备指针 */
};

// spi从设备对象
struct rt_spi_device
{
    struct rt_device parent;  /* 设备基类 */ 
    struct rt_spi_bus *bus;   /* 指向挂载的SPI总线设备 */

    struct rt_spi_configuration config;  /* SPI从设备传输模式配置结构体 */
    void   *user_data;
};

/**
 * SPI从设备传输模式配置结构体
 */
struct rt_spi_configuration
{
    rt_uint8_t mode;
    rt_uint8_t data_width;
    rt_uint16_t reserved;

    rt_uint32_t max_hz;
};

int ssd1306_attach_to_spi_bus(void)
{
    struct rt_spi_device *spi1_dev_ssd1306;
    struct rt_spi_configuration cfg;
    
    /* ssd1306 硬件引脚配置 */
    rt_pin_mode(SSD1306_DC_PIN, PIN_MODE_OUTPUT);
    rt_pin_mode(SSD1306_RST_PIN, PIN_MODE_OUTPUT);
    rt_pin_write(SSD1306_DC_PIN, 1);
    rt_pin_write(SSD1306_RST_PIN, 1);
    
    /* 在 spi1 总线上挂载一个设备 */
    rt_hw_spi_device_attach("spi1", OLED_DEV_NAME, GPIOC, GPIO_PIN_1);
    
    /* 配置spi从设备 */
    cfg.data_width = 8;
    cfg.max_hz = 20 * 1000 * 1000;  // 20Mhz
    cfg.mode = RT_SPI_MASTER | RT_SPI_MODE_0 | RT_SPI_MSB;
    spi1_dev_ssd1306 = (struct rt_spi_device *)rt_device_find(OLED_DEV_NAME);
    spi1_dev_ssd1306->config = cfg;  // 由于创建从设备对象的时候并没有配置对象，这里设置好spi从设备通信是主设备的配置，第一次操作从设备的时候会自动调用rt_spi_configure() 配置主设备（总线）
//    rt_spi_configure(spi1_dev_ssd1306, &cfg); // 或者直接调用配置函数配置主设备（总线）
    return 0;
}

int dfs_mkfs(const char * fs_name, const char * device_name);
// shell 命令：mkfs -t elm w25q16(块设备名字) 

int dfs_mount(const char   *device_name,
              const char   *path,
              const char   *filesystemtype,
              unsigned long rwflag,
              const void   *data);

#include "dfs_fs.h"
/* 挂载文件系统从w25q16块设备，elm：文件系统类型elmfat */
if (dfs_mount("w25q16", "/", "elm", 0, 0) == 0)
{
    rt_kprintf("Filesystem initialized!\n");
}
else
{
    rt_kprintf("Failed to initialize filesystem!\n");
}

/* DFS虚拟文件系统所需宏 */
#define RT_USING_DFS
#define DFS_USING_WORKDIR
#define DFS_FILESYSTEMS_MAX 2
#define DFS_FILESYSTEM_TYPES_MAX 2
#define DFS_FD_MAX 16
#define RT_USING_DFS_ELMFAT

/* elmFatFs：通用FAT文件系统所需宏 */
#define RT_DFS_ELM_CODE_PAGE 437
#define RT_DFS_ELM_WORD_ACCESS
#define RT_DFS_ELM_USE_LFN_3
#define RT_DFS_ELM_USE_LFN 3
#define RT_DFS_ELM_LFN_UNICODE_0
#define RT_DFS_ELM_LFN_UNICODE 0
#define RT_DFS_ELM_MAX_LFN 255
#define RT_DFS_ELM_DRIVES 2
#define RT_DFS_ELM_MAX_SECTOR_SIZE 4096
#define RT_DFS_ELM_REENTRANT
#define RT_USING_DFS_DEVFS