【野火】瑞萨RA MCU创意氛围赛 基于优先级的RTOS内核

桃子念peach

一、简介
1.1 项目简介
SimpleRTOS(catOS) 是我大学实习期间为了学习 RTOS 编写的一个简单的内核，主要调度方式基于优先级抢占，该项目重构了两次，故内容和功能有所不同，最新版本仅保留了固定优先级调度方式。
本次项目内容为将该内核对野火的瑞萨启明6M5开发板进行适配，并编写简单的demo验证正确性。
第一次发帖，如果有什么错误请大家批评指正。
1.2 开发板简介
官网特性介绍如下

支持 TrustZone® 的 200MHz Arm® Cortex®-M33
安全芯片功能
1MB - 2MB 闪存、448KB 支持奇偶校验的 SRAM 和 64KB ECC SRAM
具有后台运行能力的双区闪存，以及存储块交换功能
8KB 数据闪存，提供与 EEPROM 类似的数据存储功能
100 引脚封装至 176 引脚封装
带有专用 DMA 的以太网控制器
电容触摸按键感应单元
高速和全速 USB 2.0
CAN FD（也支持CAN 2.0B）
QuadSPI 和 OctaSPI
SCI多功能串口（UART、简单 SPI、简单 I2C）
SPI/ I2C 多主接口
SDHI 和 MMC

1.3 内核设计概述
1.3.1 总体架构设计

- 抢占式优先级调度
- 可移植层
- 重写更简易更轻量级的部分库函数
- 除内核外还提供部分组件
  - 简易的`shell`程序
  - 设备驱动框架
  - 内存地址读写功能



1.3.2 优先级调度策略
内核中固定优先级调度使用了位图+链表队列的形式，利用位图寻找最高优先级任务并以有序链表的形式进行调度，并且在信号量等临界资源访问上设计了优先级天花板防止优先级反转


1.3.3 内核实现了一个以组件形式存在的 shell 命令行界面，该 shell 作为一个任务运行在 os 之上


二、适配内核
2.1 可移植接口概览
需要实现的可移植接口包括以下部分

1. /**
   
2. * @brief 硬件初始化
   
3. */
   
4. void cat_hw_init(void);
   
5. 
   
6. /**
   
7. * @brief 开始调度
   
8. *
   
9. */
   
10. void catos_start_sched(void);
    
11. 
    
12. /**
    
13. * @brief 上下文切换
    
14. *
    
15. */
    
16. //void cat_hw_context_switch(void);
    
17. /**
    
18. * @brief 上下文切换
    
19. *
    
20. * @param  from_task_sp_addr 上一个任务tcb中堆栈指针变量的 *地址*
    
21. * @param  to_task_sp_addr   下一个任务tcb中堆栈指针变量的 *地址*
    
22. */
    
23. void cat_hw_context_switch(cat_uint32_t from_task_sp_addr, cat_uint32_t to_task_sp_addr);
    
24. 
    
25. /**
    
26. * @brief 切换到第一个任务的上下文
    
27. *
    
28. * @param  first_task_sp_addr  要切换的任务tcb中堆栈指针变量的 *地址*
    
29. */
    
30. void cat_hw_context_switch_to_first(cat_uint32_t first_task_sp_addr);
    
31. 
    
32. /**
    
33. * @brief 关中断进临界区
    
34. *
    
35. * @return cat_uint32_t
    
36. */
    
37. cat_uint32_t cat_hw_irq_disable(void);
    
38. 
    
39. /**
    
40. * @brief 开中断出临界区
    
41. *
    
42. * @param status
    
43. */
    
44. void cat_hw_irq_enable(cat_uint32_t status);
    
45. 
    
46. /**
    
47. * @brief 栈初始化
    
48. *
    
49. * @param task_entry    任务入口函数地址
    
50. * @param parameter     参数
    
51. * @param stack_addr    栈起始地址
    
52. * @param exit          任务退出函数地址
    
53. * @return cat_uint8_t*     初始化后的栈顶地址
    
54. */
    
55. cat_uint8_t *cat_hw_stack_init(void *task_entry, void *parameter, cat_uint8_t *stack_addr, void *exit);

复制代码

2.2 硬件初始化
在硬件初始化中主要是设置系统时钟中断频率，初始化时设置时钟中断为关闭状态

1. /**
   
2. * @brief 硬件初始化
   
3. */
   
4. void cat_hw_init(void)
   
5. {
   
6. /* 设置系统时钟中断频率为100Hz(每秒100次) */
   
7. cat_set_systick_period(CATOS_SYSTICK_MS);
   
8. }
   
9. 
   
10. /**
    
11. * @brief 初始化时钟中断
    
12. *
    
13. * @param ms 每个tick的时间(ms)
    
14. */
    
15. static void cat_set_systick_period(cat_uint32_t ms)
    
16. {
    
17. cat_uint32_t err = 0;
    
18. cat_uint32_t IT_Period = 0;
    
19. 
    
20. IT_Period = ms * SystemCoreClock / 1000;
    
21. 
    
22. //err = SysTick_Config(IT_Period);
    
23. 
    
24. /* 如果设定的周期太离谱就停在这 */
    
25. if ((IT_Period - 1UL) > SysTick_LOAD_RELOAD_Msk)
    
26. {
    
27. err = 1;
    
28. }
    
29. assert(0 == err);
    
30. 
    
31. SysTick->LOAD = (uint32_t)(IT_Period - 1UL); /* 设置重装载寄存器 */
    
32. NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* 设置时钟中断优先级 */
    
33. SysTick->VAL = 0UL; /* 设置计数器装载值 */
    
34. SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | /* 设定为内核时钟FCLK */
    
35. SysTick_CTRL_TICKINT_Msk | /* 设定为systick计数器倒数到0时触发中断 */
    
36. ~SysTick_CTRL_ENABLE_Msk; /* 关闭定时器中断，若创建任务则在catos_start_sched()中开启该中断 */
    
37. 
    
38. }

复制代码

2.3 开始调度与切换到第一个任务的上下文
开始调度需要从就绪表中获取最高优先级任务并设置为当前任务，并且在恢复第一个任务上下文之前需要打开时钟中断并初始化 pendsv 中断以保证调度的正常工作。
注：这里暂时没有对不使用 fpu 的情况适配，参考 freertos 的可移植接口实现。

1. /**
   
2. * @brief 开始调度
   
3. *
   
4. */
   
5. void catos_start_sched(void)
   
6. {
   
7. cat_uint32_t tmp_reg = 0;
   
8. struct _cat_task_t *first_task = NULL;
   
9. 
   
10. /* 获取最高优先级任务 */
    
11. first_task = cat_sp_task_highest_ready();
    
12. 
    
13. /* 因为是第一个任务，不用像调度时判断是否和上一个任务一样，直接赋值给当前任务就行 */
    
14. cat_sp_cur_task = first_task;
    
15. 
    
16. /* 允许调度(打开调度锁，并且不在该处进行调度) */
    
17. cat_sp_task_sched_enable_without_sched();
    
18. 
    
19. /* 开启时钟中断 */
    
20. SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;
    
21. 
    
22. /* 设置pendsv中断优先级 */
    
23. tmp_reg = MEM32(NVIC_SHPR3);
    
24. tmp_reg |= NVIC_PENDSV_PRI;
    
25. MEM32(NVIC_SHPR3) = tmp_reg;
    
26. 
    
27. /* 切换到第一个任务 */
    
28. cat_hw_context_switch_to_first((cat_uint32_t)&(first_task->sp));
    
29. }
    
30. 
    
31. /**
    
32. * @brief 切换到第一个任务的上下文
    
33. *
    
34. */
    
35. void cat_hw_context_switch_to_first(void)
    
36. {
    
37. __enable_irq();
    
38. __ISB();
    
39. 
    
40. /* 各个寄存器地址 */
    
41. __asm volatile (
    
42. ".equ SCB_ICSR, 0xE000ED04 \n" // 中断控制寄存器
    
43. ".equ SCB_VTOR, 0xE000ED08 \n" // 中断向量表偏移寄存器
    
44. ".equ ICSR_PENDSVSET, 0x10000000 \n" // pendsv触发值
    
45. 
    
46. ".equ SHPR3_PRI_14, 0xE000ED22 \n" // 系统异常handler优先级寄存器 3 (PendSV).
    
47. ".equ PRI_LVL_PENDSV, 0xFF \n"// pendsv优先级 (最低).
    
48. ".equ SHPR3_PRI_15, 0xE000ED23 \n"// 系统异常handler优先级寄存器 3 (Systick).
    
49. 
    
50. "ldr r1, =cat_context_to_task_sp_ptr \n"
    
51. "str r0, [r1] \n"
    
52. 
    
53. #if __FPU_USED
    
54. //#error "__FPU_USED"
    
55. /* 清除control寄存器的FPCA */
    
56. "mrs r2, control \n" /* read */
    
57. "bic r2, r2, #0x04 \n" /* modify */
    
58. "msr control, r2 \n" /* write-back */
    
59. #else
    
60. #error "must use fpu"
    
61. #endif
    
62. 
    
63. /* 将变量 cat_context_from_task_sp_ptr 设置为0*/
    
64. "ldr r1, =cat_context_from_task_sp_ptr \n"
    
65. "mov r0, #0 \n"
    
66. "str r0, [r1] \n"
    
67. 
    
68. "mov r4, #0x1234 \n"
    
69. 
    
70. /* 触发pendsv中断，允许中断后会立即进入pendsv切换 */
    
71. "ldr r0, =SCB_ICSR \n"
    
72. "ldr r1, =ICSR_PENDSVSET \n"
    
73. "str r1, [r0] \n" /* *(SCB_ICSR) = "ICSR_PENDSVSET */
    
74. 
    
75. /* 不会到达这里 */
    
76. "dsb \n"
    
77. "isb \n"
    
78. "svc 0 \n"
    
79. );
    
80. }

复制代码

2.4 上下文切换

上下文切换使用 pendsv 中断进行，主要工作为保存当前任务堆栈和寄存器以及恢复下一个任务的堆栈和寄存器。

1. /**
   
2. * void cat_hw_context_switch(void)
   
3. * 触发pendsv中断进行任务切换(pendsv的优先级在开始第一个任务时已经设置)
   
4. */
   
5.     .global cat_hw_context_switch
   
6.     .type cat_hw_context_switch, %function
   
7. cat_hw_context_switch:
   
8.     /* 将两个任务的堆栈指针变量的 *地址* 加载到临时变量中 */
   
9.     /* cat_context_from_task_sp_ptr = &(cat_sp_cur_task->sp) */
   
10.     ldr r2, =cat_context_from_task_sp_ptr
    
11.     str r0, [r2]
    
12. 
    
13.     /* cat_context_to_task_sp_ptr = &(cat_sp_next_task->sp) */
    
14.     ldr r2, =cat_context_to_task_sp_ptr
    
15.     str r1, [r2]
    
16. 
    
17.     /* 触发pendsv中断进行切换 */
    
18.     ldr r0, =SCB_ICSR      
    
19.     ldr r1, =ICSR_PENDSVSET
    
20.     str r1, [r0]                /* *(SCB_ICSR) = ICSR_PENDSVSET */
    
21.     bx  lr
    
22. 
    
23. 
    
24. void PendSV_Handler(void)
    
25. {
    
26.     __asm volatile (
    
27.         /* 关闭全局中断并保存当前中断屏蔽寄存器中的值方便恢复 */
    
28.     "mrs r2, primask                            \n"
    
29.     "cpsid i                                    \n"
    
30. 
    
31.     /* 保存中断屏蔽寄存器状态 */
    
32.     "push {r2}                                  \n"
    
33. 
    
34.     /* 获取from任务的堆栈指针变量中的值 */
    
35.     /* 在进入pendsv之前 cat_context_from_task_sp_ptr = &(from_task->sp) */
    
36.     /** 故有：
    
37.      * r0 =  &(from_task->sp)
    
38.      * r1 = *(&(from_task->sp)) 等价于 r1 = from_task->sp
    
39.      */
    
40.     "ldr r0, =cat_context_from_task_sp_ptr      \n"
    
41.     "ldr r1, [r0]                               \n"
    
42.     /* 如果为零则说明是第一个任务 */
    
43.     "cbz r1, switch_to_thread                   \n"
    
44. 
    
45. /* 暂时可能用不到trustzone, 因此直接跳转 */
    
46.     "b contex_ns_store                          \n"
    
47. /* 暂时可能用不到 END */
    
48. 
    
49. "contex_ns_store:                               \n"
    
50. 
    
51.     /* 用户级堆栈是psp，特权级堆栈是msp */
    
52.     /* 任务用的是psp，将当前寄存器保存到堆栈中 */
    
53.     "mrs r1, psp                                \n"
    
54. 
    
55. #if __FPU_USED
    
56.     "tst lr, #0x10                              \n"
    
57.     "it eq                                      \n"
    
58.     "vstmdbeq r1!, {s16-s31}                    \n"
    
59. 
    
60. #if BSP_TZ_NONSECURE_BUILD
    
61. #else
    
62.         /* Stack R4-R11 on the process stack. Also stack LR since the FPU is supported. */
    
63.         "STMDB     R1!, {R4-R11, LR}             \n"
    
64. #endif
    
65. #else
    
66. #error "must use fpu"
    
67. #endif
    
68. 
    
69. #if BSP_TZ_NONSECURE_BUILD
    
70. #error "should not use BSP_TZ_NONSECURE_BUILD"
    
71. #elif RM_CATOS_PORT_PSPLIM_PRESENT
    
72.         "mrs     r3, psplim                      \n" /* R3 = PSPLIM. */
    
73.         "stmdb   r1!, {r3}                       \n"
    
74. #endif
    
75. 
    
76.     /* 记录最后的指针到任务栈curstk->stack */
    
77.     /* 更新tcb的堆栈指针变量值 */
    
78.     /**
    
79.         from_task->sp = r1
    
80.      */
    
81.     "ldr r0, [r0]                               \n"
    
82.     "str r1, [r0]                               \n"
    
83. 
    
84. #if !__FPU_USED
    
85. #error "must use fpu"
    
86. #endif
    
87. 
    
88.         /* 上下文保存结束 */
    
89.                
    
90. "switch_to_thread:                              \n"
    
91.     "ldr r1, =cat_context_to_task_sp_ptr        \n"
    
92.     "ldr r1, [r1]                               \n"
    
93.     "ldr r1, [r1]                               \n"
    
94. 
    
95. #if BSP_TZ_NONSECURE_BUILD
    
96. #error "not support BSP_TZ_NONSECURE_BUILD"
    
97. #elif RM_CATOS_PORT_PSPLIM_PRESENT
    
98.         "LDMIA   R1!, {R2}                       \n" /* R1 = PSPLIM */
    
99.         "MSR     PSPLIM, R2                      \n" /* Restore the PSPLIM register value for the task. */
    
100. #endif
     
101. 
     
102. #if BSP_TZ_NONSECURE_BUILD
     
103. #error "not support BSP_TZ_NONSECURE_BUILD"
     
104. #endif
     
105. 
     
106.         "b contex_ns_load                           \n"
     
107. "contex_ns_load:                                    \n"
     
108. 
     
109. #if __FPU_USED
     
110. #if BSP_TZ_NONSECURE_BUILD
     
111.   #error "not support BSP_TZ_NONSECURE_BUILD"
     
112. #else
     
113.         /* Restore R4-R11 and LR from the process stack. */
     
114.         "LDMIA   R1!, {R4-R11, LR}               \n"
     
115. #endif
     
116. 
     
117.         /* Check to see if the thread being restored is using the FPU. If so, restore S16-S31. */
     
118.         "TST       LR, #0x10                     \n"
     
119.         "IT        EQ                            \n"
     
120.         "VLDMIAEQ  R1!, {S16-S31}                \n"
     
121. #else
     
122. #error "must use fpu"
     
123. #endif
     
124. 
     
125. "pendsv_exit:                                   \n"
     
126.     "msr psp, r1                                \n"
     
127. 
     
128. #if !__FPU_USED
     
129. #error "must use fpu"
     
130. #endif
     
131. 
     
132.     "pop {r2}                                   \n"
     
133. 
     
134.     /* 恢复屏蔽寄存器值 */
     
135.     "msr primask, r2                            \n"
     
136. 
     
137. #if __FPU_USED
     
138.     "bx lr                                      \n"
     
139. #else
     
140. #error "must use fpu"
     
141. #endif
     
142.     );
     
143. }

复制代码

2.5 临界区的开关中断
开关中断主要是对primask的操作，和 cortex-m3 差不多，比较简单。

1. /**
   
2. * cat_uint32_t cat_hw_irq_disable(void)
   
3. * 关中断方式进入临界区
   
4. * primask-->r0
   
5. */
   
6.     .global cat_hw_irq_disable
   
7.     .type cat_hw_irq_disable, %function
   
8. cat_hw_irq_disable:
   
9.     mrs r0, primask             /* ret = primask */
   
10.     cpsid I                     /* disable irq */
    
11.     bx lr                       /* return ret */
    
12. 
    
13. /**
    
14. * void cat_hw_irq_enable(cat_uint32_t status)
    
15. * 开中断方式出临界区
    
16. * r0-->status
    
17. */
    
18.     .global cat_hw_irq_enable
    
19.     .type cat_hw_irq_enable, %function
    
20. cat_hw_irq_enable:
    
21.     msr primask, r0             /* primask = status */
    
22.     bx lr

复制代码

2.6 任务栈初始化
在任务创建时需要根据任务的相关信息对任务栈帧中各项进行初始化，包括设置 psr 寄存器、任务入口地址、退出函数地址和任务参数。
需要特别注意的是 cortex-m33 还需要正确设置 psplim 等寄存器。

1. /**
   
2. * @brief 栈初始化
   
3. *
   
4. * @param task_entry    任务入口函数地址
   
5. * @param parameter     参数
   
6. * @param stack_addr    栈起始地址
   
7. * @param exit          任务退出函数地址
   
8. * @return cat_uint8_t*     初始化后的栈顶地址
   
9. */
   
10. cat_uint8_t *cat_hw_stack_init(void *task_entry, void *arg, cat_uint8_t *stack_addr, void *exit_func)
    
11. {
    
12.   struct _stack_frame *stack_frame;
    
13.   cat_uint32_t         *stack;
    
14.   cat_uint32_t         i;
    
15. 
    
16.   /* 先加上4字节再8字节向下取整对齐(相当于四舍五入) */
    
17.   stack = stack_addr + sizeof(cat_uint32_t);
    
18.   stack = (cat_uint8_t *)CAT_ALIGN_DOWN((cat_uint32_t)stack, 8);
    
19. 
    
20.     /* task context saved & restore by hardware: */
    
21.     *(--stack) = (cat_uint32_t)0x01000000L; /* xPSR: EPSR.T = 1, thumb mode   */
    
22.     *(--stack) = (cat_uint32_t)task_entry;       /* Entry Point */
    
23.     *(--stack) = (cat_uint32_t)exit_func; /* R14 (LR)              */
    
24.     *(--stack) = (cat_uint32_t)0x12121212L; /* R12                            */
    
25.     *(--stack) = (cat_uint32_t)0x03030303L; /* R3                             */
    
26.     *(--stack) = (cat_uint32_t)0x02020202L; /* R2                             */
    
27.     *(--stack) = (cat_uint32_t)0x01010101L; /* R1                             */
    
28.     *(--stack) = (cat_uint32_t)arg;         /* R0 : argument                  */
    
29. 
    
30. #if __FPU_USED && !BSP_TZ_NONSECURE_BUILD
    
31.     *(--stack) = (cat_uint32_t)portINITIAL_EXC_RETURN; /* exe_return值 */
    
32. #endif
    
33. 
    
34.     *(--stack) = (cat_uint32_t)0x11111111L; /* R11 */
    
35.     *(--stack) = (cat_uint32_t)0x10101010L; /* R10 */
    
36.     *(--stack) = (cat_uint32_t)0x09090909L; /* R9  */
    
37.     *(--stack) = (cat_uint32_t)0x08080808L; /* R8  */
    
38.     *(--stack) = (cat_uint32_t)0x07070707L; /* R7  */
    
39.     *(--stack) = (cat_uint32_t)0x06060606L; /* R6  */
    
40.     *(--stack) = (cat_uint32_t)0x05050505L; /* R5  */
    
41.     *(--stack) = (cat_uint32_t)0x04040404L; /* R4  */
    
42. 
    
43. #if RM_CATOS_PORT_PSPLIM_PRESENT
    
44.     *(--stack) = (cat_uint32_t)0x00; /* psplim */
    
45. #endif
    
46. 
    
47.     stack_frame = (struct _stack_frame *)stack;
    
48. #endif /* #if 0 */
    
49. 
    
50.   /* 返回当前栈指针 */
    
51.   return stack;
    
52. }

复制代码

三、板载led和串口的驱动
3.1 板载led(GPIO)
ra6m5 的引脚结构体定义

1. typedef struct _ra6m5_fire_pin_t
   
2. {
   
3.     cat_uint32_t             pin_num;
   
4.     ioport_instance_ctrl_t  *p_ctrl_ptr;
   
5.     const bsp_io_port_pin_t  gpio_pin;
   
6. }ra6m5_fire_pin_t;

复制代码

暂时只用得上输出引脚，实现 pin_write 接口，利用 fsp 库实现引脚输出

1. cat_uint8_t cat_pin_write(cat_uint32_t pin_num, cat_uint8_t val)
   
2. {
   
3.     cat_uint8_t ret = CAT_ERROR;
   
4.     ra6m5_fire_pin_t *p = &(pin_map[0]);
   
5.    
   
6.     /* 遍历pin_map数组 */
   
7.     for(; p->pin_num!=0xffff; p++)
   
8.     {
   
9.         if(p->pin_num == pin_num)
   
10.         {
    
11.             if(0 == val)
    
12.             {
    
13.                 R_IOPORT_PinWrite(p->p_ctrl_ptr, p->gpio_pin, BSP_IO_LEVEL_LOW);
    
14.                 ret = CAT_EOK;
    
15.             }
    
16.             else if(1 == val)
    
17.             {
    
18.                 R_IOPORT_PinWrite(p->p_ctrl_ptr, p->gpio_pin, BSP_IO_LEVEL_HIGH);
    
19.                 ret = CAT_EOK;
    
20.             }
    
21.             else
    
22.             {
    
23.                 /* 非法值，之后打印错误信息 */
    
24.                 ret = CAT_ERROR;
    
25.                 while(1);
    
26.             }
    
27.             
    
28.             /* 写入结束结束循环 */
    
29.             break;
    
30.         } /* if */
    
31.     } /* for */
    
32. 
    
33.     return ret;
    
34. }

复制代码

3.2 串口
野火教程以及我找到的官方例程中 ra6m5 的串口收发均使用中断实现，但在本内核中的标准输入输出函数大部分是以字符为单位，故发送接口用寄存器方式实现，串口接收仍然使用 fsp 库 + 中断实现

3.2.1 串口发送

1. static cat_int8_t ra6m5_uart_send_char(cat_device_t*dev, cat_uint32_t timeout, cat_uint8_t data)
   
2. {
   
3.     cat_int8_t ret = CAT_ERROR;
   
4.     struct _cat_ra6m5_fire_uart_private_data_t *private_data = NULL;
   
5. 
   
6.     /* 获取设备实例数据 */
   
7.     private_data = (struct _cat_ra6m5_fire_uart_private_data_t *)(dev->pri_data);
   
8. 
   
9.     sci_uart_instance_ctrl_t *p_ctrl = private_data->inst_ctrl_ptr;
   
10. 
    
11.     /* 将要发送的数据放进数据寄存器 */
    
12.     p_ctrl->p_reg->TDR = data;
    
13. 
    
14.     /* 等待发送完成或超时 */
    
15.     while(
    
16.         ((p_ctrl->p_reg->SSR_b.TEND) == 0) &&
    
17.         (0 != timeout)
    
18.     )
    
19.     {
    
20.         timeout--;
    
21.     }
    
22. 
    
23.     /* 未超时才成功 */
    
24.     if(0 != timeout)
    
25.     {
    
26.         ret = CAT_EOK;
    
27.     }
    
28. 
    
29.     return ret;
    
30. }
    
31. 
    
32. static cat_uint32_t ra6m5_uart_send(cat_device_t*dev, uint32_t timeout, uint8_t const * const buffer, uint32_t const size)
    
33. {
    
34.     (void)timeout;
    
35.     cat_uint32_t cnt = 0;
    
36.     cat_int8_t err = CAT_EOK;
    
37.    
    
38.     while(
    
39.         (CAT_EOK == err) &&
    
40.         (cnt < size)
    
41.     )
    
42.     {
    
43.         err = ra6m5_uart_send_char(dev, 0xffff, buffer[cnt]);
    
44.         cnt++;
    
45.     }
    
46. 
    
47.     /* 因为前面在一次 while 循环中无论发送是否成功 cnt 都会无条件加一，所以如果失败了就有一个多加上的计数 */
    
48.     if(CAT_ERROR == err)
    
49.     {
    
50.         cnt--;
    
51.     }
    
52. 
    
53.     return cnt;
    
54. }

复制代码

3.2.2 串口接收

1. static cat_uint32_t ra6m5_uart_recv(cat_device_t*dev, uint32_t timeout, uint8_t *buffer, uint32_t const size)
   
2. {
   
3. cat_uint32_t recv_buffer_idx = 0; /**< 串口接收缓冲区访问索引 */
   
4. cat_uint32_t err = CAT_ERROR;
   
5. struct _cat_ra6m5_fire_uart_private_data_t *private_data = NULL;
   
6. 
   
7. /* 获取设备实例数据 */
   
8. private_data = (struct _cat_ra6m5_fire_uart_private_data_t *)(dev->pri_data);
   
9. assert(NULL != private_data);
   
10. 
    
11. /* 读取 */
    
12. while(recv_buffer_idx != size)
    
13. {
    
14. while(
    
15. (false == uart4_receive_char) &&
    
16. (0 != timeout)
    
17. )
    
18. {
    
19. timeout--;
    
20. };
    
21. 
    
22. if(0 == timeout)
    
23. {
    
24. break;
    
25. }
    
26. 
    
27. while(
    
28. (cat_ringbuffer_is_empty(private_data->p_ringbuffer) == 0)
    
29. )
    
30. {
    
31. /* 获取接收到的字符 */
    
32. err = cat_ringbuffer_get(private_data->p_ringbuffer, &(buffer[recv_buffer_idx++]));
    
33. 
    
34. if(CAT_ERROR == err)
    
35. {
    
36. /* 获取失败，因为while条件判断过非空，所以出大问题 */
    
37. while(1);
    
38. }
    
39. 
    
40. if(recv_buffer_idx == size)
    
41. {
    
42. break;
    
43. }
    
44. }
    
45. 
    
46. if(cat_ringbuffer_is_empty(private_data->p_ringbuffer))
    
47. {
    
48. /* 取完才改遍flag */
    
49. uart4_receive_char = false;
    
50. }
    
51. }
    
52. 
    
53. return recv_buffer_idx;
    
54. }

复制代码

3.2.3 串口中断服务函数

1. /* uart4中断回调函数 */
   
2. void debug_uart4_callback(uart_callback_args_t *pargs)
   
3. {
   
4.     switch(pargs->event)
   
5.     {
   
6.         case UART_EVENT_RX_CHAR:
   
7.         {
   
8.             cat_ringbuffer_put(&uart4_rb, pargs->data);
   
9.             uart4_receive_char = true;
   
10.         }
    
11.         default:
    
12.         {
    
13.             break;
    
14.         }
    
15.     }
    
16. }

复制代码

3.3 基于 GPIO 引脚驱动实现 iic 总线驱动
利用 gpio 的基本输入输出实现软件 iic 功能
3.3.1 设计 iic 数据结构
因为是软件 iic，所以每个总线需要设置 scl 和 sda 引脚，并且总线时序中可能需要不同的 delay 操作。此外，is_init 用来防止重复初始化同一个总线。

1. typedef struct _cat_iic_bus_t
   
2. {
   
3. cat_uint32_t scl;
   
4.     cat_uint32_t sda;
   
5.     cat_bool_t   is_init;
   
6.     cat_uint32_t delay_us;
   
7.     cat_uint32_t timeout_us;
   
8.     const cat_uint8_t *name;
   
9. }cat_iic_bus_t;

复制代码

3.3.2 设计引脚电平操作
因为有 GPIO 驱动作为基础，设置引脚输入输出和高低电平直接调用 pin 驱动即可

1. #define SET_SCL(bus, val)    cat_pin_write((bus)->scl, val)
   
2. #define SET_SDA(bus, val)    cat_pin_write((bus)->sda, val)
   
3. #define GET_SCL(bus)         cat_pin_read((bus)->scl)
   
4. #define GET_SDA(bus)         cat_pin_read((bus)->sda)
   
5. 
   
6. #define SDA_OUT(bus)         cat_pin_set_mode((bus)->sda, CAT_PIN_MODE_OUTPUT);
   
7. #define SDA_IN(bus)          cat_pin_set_mode((bus)->sda, CAT_PIN_MODE_INPUT);
   
8. 
   
9. #define SCL_L(bus)  SET_SCL((bus), CAT_PIN_LOW)
   
10. #define SDA_L(bus)  SET_SDA((bus), CAT_PIN_LOW)
    
11. #define SDA_H(bus)  SET_SDA((bus), CAT_PIN_HIGH)

复制代码

四、调试验证
4.1 创建 demo 项目
在 projects 目录利用 rasc 工具生成 keil 裸机工程，只需配置 led 引脚以及 uart 串口


4.2 编写程序创建任务
在 hal_entry 中创建用户任务

1. #include "hal_data.h"
   
2. #include "catos.h"
   
3. 
   
4. FSP_CPP_HEADER
   
5. void R_BSP_WarmStart(bsp_warm_start_event_t event);
   
6. FSP_CPP_FOOTER
   
7. 
   
8. /*******************************************************************************************************************//**
   
9. * main() is generated by the RA Configuration editor and is used to generate threads if an RTOS is used.  This function
   
10. * is called by main() when no RTOS is used.
    
11. **********************************************************************************************************************/
    
12. #define TASK1_STACK_SIZE    (1024)
    
13. #define TASK2_STACK_SIZE    (1024)
    
14. 
    
15. struct _cat_task_t task1;
    
16. struct _cat_task_t task2;
    
17. 
    
18. cat_stack_type_t task1_env[TASK1_STACK_SIZE];
    
19. cat_stack_type_t task2_env[TASK2_STACK_SIZE];
    
20. 
    
21. uint32_t sched_task1_times = 0;
    
22. uint32_t sched_task2_times = 0;
    
23. 
    
24. #define BOARD_LED_PIN 0
    
25. 
    
26. void board_led_init(void)
    
27. {
    
28.     cat_pin_init(BOARD_LED_PIN, CAT_PIN_MODE_OUTPUT);
    
29. }
    
30. 
    
31. void board_led_on(void)
    
32. {
    
33.     cat_pin_write(BOARD_LED_PIN, CAT_PIN_LOW);
    
34. }
    
35. 
    
36. void board_led_off(void)
    
37. {
    
38.     cat_pin_write(BOARD_LED_PIN, CAT_PIN_HIGH);
    
39. }
    
40. 
    
41. void task1_entry(void *arg)
    
42. {
    
43. 
    
44.     for(;;)
    
45.     {
    
46.         sched_task1_times++;
    
47.         board_led_on();
    
48.         cat_sp_task_delay(100);
    
49.         board_led_off();
    
50.         cat_sp_task_delay(100);
    
51.     }
    
52. }
    
53. 
    
54. void task2_entry(void *arg)
    
55. {
    
56.     for(;;)
    
57.     {
    
58.         cat_sp_task_delay(100);
    
59.         //CAT_DEBUG_PRINTF("[task2] %d\r\n", catos_systicks);
    
60.     }
    
61. }
    
62. 
    
63. void hal_entry(void)
    
64. {
    
65.     /* TODO: add your own code here */
    
66. 
    
67.     /* 初始化os */
    
68.     catos_init();
    
69. 
    
70.     /* 利用pin驱动初始化板载led */
    
71.     board_led_init();
    
72. 
    
73.     /* 测试创建任务运行 */
    
74.     cat_sp_task_create(
    
75.       (const uint8_t *)"task1_task",
    
76.       &task1,
    
77.       task1_entry,
    
78.       NULL,
    
79.       0,
    
80.       task1_env,
    
81.       TASK1_STACK_SIZE
    
82.     );
    
83. 
    
84.     cat_sp_task_create(
    
85.       (const uint8_t *)"task2_task",
    
86.       &task2,
    
87.       task2_entry,
    
88.       NULL,
    
89.       0,
    
90.       task2_env,
    
91.       sizeof(task2_env)
    
92.     );
    
93. 
    
94. 
    
95.     /* 开始调度 */
    
96.     catos_start_sched();
    
97. 
    
98.     /* 不会到达这里 */
    
99. 
    
100.     while(1);
     
101. 
     
102. #if BSP_TZ_SECURE_BUILD
     
103.     /* Enter non-secure code */
     
104.     R_BSP_NonSecureEnter();
     
105. #endif
     
106. }
     
107. 
     

复制代码

4.3 烧写与验证
使用 xshell 连接串口并烧录程序，可以观察到l led 闪烁，并且串口有 shell 的信息，命令可以正常使用。


五、总结
在整个项目过程中，因为涉及底层操作，并且教程还比较少，走了不少弯路，但总体来说还是很不错的，特别是 fsp 配置方面。
建议瑞萨可以在 eestudio 适配更多调试器方便开发者使用；并且在使用野火 dap 时发现其在 ubuntu 下要被识别比较麻烦，如果能改进，使用场景会更多。

六、附件与项目地址
B站视频介绍：【野火】瑞萨RA MCU创意氛围赛 基于优先级的实时RTOS内核_哔哩哔哩_bilibili
Github链接  ：Simple-XX/SimpleRTOS at ver2 (github.com)

ID-fHtdZc

顶顶顶，太厉害啦

桃子念peach

ID-fHtdZc 发表于 2023-7-1 14:44
顶顶顶，太厉害啦

谢谢老哥，互相学习嘿嘿