2021-06-02

最新推荐文章于 2024-06-29 11:15:00 发布

海水与火焰

最新推荐文章于 2024-06-29 11:15:00 发布

阅读量717

点赞数

分类专栏： RTT 文章标签：嵌入式单片机

本文链接：https://blog.csdn.net/u011888107/article/details/117460794

版权

RTT 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

RTthread再学习记录（一）

前言
一、RTthread移植代码自动生成方案
二、使用CUBEMX在STM32F4上移植RTT
- 1.官方提供的教程
- 2.解决RTT移植的一些细节问题
总结

前言

本人之前很少写技术博客，一是因为自己懒，二是因为在公司做项目涉及的一些东西不方便写在网上，不过因为最近离职找工作的原因，为了不让自己的技术荒废，就打算在CSDN上做个学习性质的博客，把一些常用的技术通过实践记录一下。也算是对自己职业生涯的鞭策。
关于RTthread其实我早有耳闻，自己最早接触的RTOS是UCOS，后来在公司做项目用的是FREERTOS，在我看来这两者都很好用，且差别不大，用的也算舒服。以前说到国产RTOS，也会有人对我提起过RTthread，虽说它发展较早（我记得大概是2006年发布的吧），但是身边的人包括老板都认为国产的RTOS没经过时间检验，用在产品上会有技术风险。所以以前我也只是对它有耳闻，并未去尝试项目。直到最近找工作才发现，原来国内还是有不少公司在用它。受最近中美贸易战的影响，国产软硬件替代也逐渐成了国内公司未来发展的一个新趋势，这就更凸显它的存在价值。作为一个追赶技术潮流的IT人怎可还对它视而不见呢，so赶紧到碗里来吧。

一、RTthread移植代码自动生成方案

为啥要先讲这个？也许很多老嵌入式工程师不服，老老实实下载源码，修改移植到工程不好么？我只能说以前我也很天真，在学校刚学习RTOS时也喜欢这么干，但是自从用过了STM CUBEMX这种自动化的代码生成工具，就真的回不去了，回不去了，回不去了（重要的事情说3遍）。感叹下，我刚学嵌入式的时候还没这种玩意，只能说时代变化快，不跟上就要被淘汰。
废话不多说了，目前RTthread代码自动生成大致有4种方案：
1.ENV配置工具生成（可生成MDK工程）。
2.官方开发环境RTthread Studio可视化配置。
3.安装RTthread插件用CUBEMX生成。
4.直接用MDK自带的pack install移植。
方案1缺点主要是大部分操作在命令行下完成，对新手不友好。
方案2其实是最简单的，但是要熟悉IDE，不过因为是采用Eclipes框架，熟悉eclipes的开发人员应该很好上手。
方案3缺点是RTthread作为第三方插件，CUBEMX的支持并没有FREERTOS那么全面，需要少量修改代码，优点也很明显，stm32外设配置简单。
方案4对MDK的老用户友好，但是我还是不太习惯，主要是国内网络环境下载pack一直都是问题，再加上不好直接修改源码，嗯。。总之个人不喜欢吧。
作为一个常年使用CubeMX的老油条，我还是老老实实用方案3吧

二、使用CUBEMX在STM32F4上移植RTT

1.官方提供的教程

教程链接：官方移植教程

手上刚好有块STM32f429-DISC开发板，就按官方教程练下手吧。

第一步就不需要多说了，按官方教程给你的CUBEMX安装RTT插件，装好后效果如图：
第二步按CUBEMX的正常步骤配置开发板，因为是用的官方开发板，可以通过选取开发板新建工程。
打开工程，可以看到板载外设基本都配置好了，用CUBEMX不就是为了省心么，哈哈。不过我还是喜欢习惯性的改下系统时基和时钟树配置，如下：
系统时钟频率给我拉满，方能体现我大F４的威力。
再就是要配置下RTT操作系统了，基本配置我都是按默认的来，内存配置，因为我要用动态内存堆所以全打开
再就是配置下RTT的特色控制台FinSH——一个命令行输入输出控制台，它能让你产生玩linux Shell的幻觉。呵呵，开玩笑啦，虽然还是太简陋，没法和真正的Shell比，不过这么一弄整个系统瞬间高大上有木有。我记得以前玩FreeRTOS 查看系统任务信息，还要专门写个监控任务打印，现在有了Finsh就完全不需要这么麻烦了，一个命令list_thread就可以解决，就问你调试爽不爽。
其他关于工程生成的参数选项配置，大家就参考官方文档来就行了。点击生成代码按钮，你就得到了一个移植完成度接近99%的RTT工程了。

2.解决RTT移植的一些细节问题

打开经过CUBEMX生成的代码工程结构还是很清晰的
在这里插入图片描述
FinSH代码作为系统的SHELL单独放在Middlewares/RT-Thread/RTOS/shell工程文件夹下，而操作系统的内核源码则放在Middlewares/RT-Thread/RTOS/kernel工程文件夹下，其他文件夹和Cubemx裸机工程基本一样。

编译一下。。报错如下： “Undefined symbol rt_hw_console_getchar (referrred from shell.o)”，查阅官方文档得知原来还需要写2个函数实现FinSH的输入和输出，并且官方给出了参考示例。如下：
FinSH移植官方文档

考虑到STM32f429-DISC开发板自带一个调试器串口，那就用它作为输入和输出吧，查阅开发板手册，得知该串口是USART１，使用管脚PA9，PA10，其实在CUBEMX里已经配置好了。这里推荐用官方示例的环形缓冲区+中断方式作为串口接收，官方提供的轮询方案我也试过，接收容易丢包，实时性差。
拷贝官方串口初始化代码和中断示例代码到stm32f4xx_it.c，这里有一点要说明，就是想让串口初始化代码在系统板级始化时调用，写的时候需要在后面加上INIT_BOARD_EXPORT(uart_init);导出到初始化列表，这里uart_init是串口初始化函数名。

/* USER CODE BEGIN PD */
#define rt_ringbuffer_space_len(rb) ((rb)->buffer_size - rt_ringbuffer_data_len(rb))
#define UART_RX_BUF_LEN 16
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN PV */
rt_uint8_t uart_rx_buf[UART_RX_BUF_LEN] = {0};
struct rt_ringbuffer  uart_rxcb;         /* 定义一个 ringbuffer cb */
static UART_HandleTypeDef UartHandle;
static struct rt_semaphore shell_rx_sem; /* 定义一个静态信号量 */
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
/* USER CODE BEGIN PFP */
struct rt_ringbuffer
{
    rt_uint8_t *buffer_ptr;

    rt_uint16_t read_mirror : 1;
    rt_uint16_t read_index : 15;
    rt_uint16_t write_mirror : 1;
    rt_uint16_t write_index : 15;

    rt_int16_t buffer_size;
};

enum rt_ringbuffer_state
{
    RT_RINGBUFFER_EMPTY,
    RT_RINGBUFFER_FULL,
    /* half full is neither full nor empty */
    RT_RINGBUFFER_HALFFULL,
};

rt_inline enum rt_ringbuffer_state rt_ringbuffer_status(struct rt_ringbuffer *rb)
{
    if (rb->read_index == rb->write_index)
    {
        if (rb->read_mirror == rb->write_mirror)
            return RT_RINGBUFFER_EMPTY;
        else
            return RT_RINGBUFFER_FULL;
    }
    return RT_RINGBUFFER_HALFFULL;
}

/** 
 * get the size of data in rb 
 */
rt_size_t rt_ringbuffer_data_len(struct rt_ringbuffer *rb)
{
    switch (rt_ringbuffer_status(rb))
    {
    case RT_RINGBUFFER_EMPTY:
        return 0;
    case RT_RINGBUFFER_FULL:
        return rb->buffer_size;
    case RT_RINGBUFFER_HALFFULL:
    default:
        if (rb->write_index > rb->read_index)
            return rb->write_index - rb->read_index;
        else
            return rb->buffer_size - (rb->read_index - rb->write_index);
    };
}

void rt_ringbuffer_init(struct rt_ringbuffer *rb,
                        rt_uint8_t           *pool,
                        rt_int16_t            size)
{
    RT_ASSERT(rb != RT_NULL);
    RT_ASSERT(size > 0);

    /* initialize read and write index */
    rb->read_mirror = rb->read_index = 0;
    rb->write_mirror = rb->write_index = 0;

    /* set buffer pool and size */
    rb->buffer_ptr = pool;
    rb->buffer_size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE);
}

/**
 * put a character into ring buffer
 */
rt_size_t rt_ringbuffer_putchar(struct rt_ringbuffer *rb, const rt_uint8_t ch)
{
    RT_ASSERT(rb != RT_NULL);

    /* whether has enough space */
    if (!rt_ringbuffer_space_len(rb))
        return 0;

    rb->buffer_ptr[rb->write_index] = ch;

    /* flip mirror */
    if (rb->write_index == rb->buffer_size-1)
    {
        rb->write_mirror = ~rb->write_mirror;
        rb->write_index = 0;
    }
    else
    {
        rb->write_index++;
    }

    return 1;
}
/**
 * get a character from a ringbuffer
 */
rt_size_t rt_ringbuffer_getchar(struct rt_ringbuffer *rb, rt_uint8_t *ch)
{
    RT_ASSERT(rb != RT_NULL);

    /* ringbuffer is empty */
    if (!rt_ringbuffer_data_len(rb))
        return 0;

    /* put character */
    *ch = rb->buffer_ptr[rb->read_index];

    if (rb->read_index == rb->buffer_size-1)
    {
        rb->read_mirror = ~rb->read_mirror;
        rb->read_index = 0;
    }
    else
    {
        rb->read_index++;
    }

    return 1;
}

/* 初始化串口，中断方式 */
static int uart_init(void)
{
    /* 初始化串口接收 ringbuffer  */
    rt_ringbuffer_init(&uart_rxcb, uart_rx_buf, UART_RX_BUF_LEN);

    /* 初始化串口接收数据的信号量 */
    rt_sem_init(&(shell_rx_sem), "shell_rx", 0, 0);

    /* 初始化串口参数，如波特率、停止位等等 */
    UartHandle.Instance = USART1;
    UartHandle.Init.BaudRate   = 115200;
    UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    UartHandle.Init.Mode       = UART_MODE_TX_RX;
    UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
    UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    UartHandle.Init.StopBits   = UART_STOPBITS_1;
    UartHandle.Init.Parity     = UART_PARITY_NONE;

    /* 初始化串口引脚等 */
    if (HAL_UART_Init(&UartHandle) != HAL_OK)
    {
        while (1);
    }

    /* 中断配置 */
    __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_RXNE);
    HAL_NVIC_EnableIRQ(USART2_IRQn);
    HAL_NVIC_SetPriority(USART2_IRQn, 3, 3);

    return 0;
}
INIT_BOARD_EXPORT(uart_init);

/* 移植控制台，实现控制台输出, 对接 rt_hw_console_output */
void rt_hw_console_output(const char *str)
{
    rt_size_t i = 0, size = 0;
    char a = '\r';

    __HAL_UNLOCK(&UartHandle);

    size = rt_strlen(str);
    for (i = 0; i < size; i++)
    {
        if (*(str + i) == '\n')
        {
            HAL_UART_Transmit(&UartHandle, (uint8_t *)&a, 1, 1);
        }
        HAL_UART_Transmit(&UartHandle, (uint8_t *)(str + i), 1, 1);
    }
}

/* 移植 FinSH，实现命令行交互, 需要添加 FinSH 源码，然后再对接 rt_hw_console_getchar */
/* 中断方式 */
char rt_hw_console_getchar(void)
{
    char ch = 0;

    /* 从 ringbuffer 中拿出数据 */
    while (rt_ringbuffer_getchar(&uart_rxcb, (rt_uint8_t *)&ch) != 1)
    {
        rt_sem_take(&shell_rx_sem, RT_WAITING_FOREVER);
    } 
    return ch;   
}

void USART1_IRQHandler(void)
{
  /* USER CODE BEGIN USART1_IRQn 0 */
   int ch = -1;
 //   rt_base_t level;
    /* enter interrupt */
    rt_interrupt_enter();          //在中断中一定要调用这对函数，进入中断

    if ((__HAL_UART_GET_FLAG(&(UartHandle), UART_FLAG_RXNE) != RESET) &&
        (__HAL_UART_GET_IT_SOURCE(&(UartHandle), UART_IT_RXNE) != RESET))
    {
        while (1)
        {
            ch = -1;
            if (__HAL_UART_GET_FLAG(&(UartHandle), UART_FLAG_RXNE) != RESET)
            {
                ch =  UartHandle.Instance->DR & 0xff;
            }
            if (ch == -1)
            {
                break;
            }  
            /* 读取到数据，将数据存入 ringbuffer */
            rt_ringbuffer_putchar(&uart_rxcb, ch);
        }        
        rt_sem_release(&shell_rx_sem);
    }

    /* leave interrupt */
    rt_interrupt_leave();    //在中断中一定要调用这对函数，离开中断
  /* USER CODE END USART1_IRQn 0 */
  HAL_UART_IRQHandler(&huart1);
  /* USER CODE BEGIN USART1_IRQn 1 */

  /* USER CODE END USART1_IRQn 1 */
}

另外由于在RTT操作系统里，main（）函数只是系统启动后的一个任务入口（真正的程序入口是int $S u b$ $main(void)），所以系统时钟初始化，包括串口初始化（因为系统启动时要调用Finsh打印开机信息），都不要写在里面了，实现最好都写在rt_hw_board_init（）里面，系统启动时它会被调用，此时任务还未启动。建议注释掉Cubemx生成main函数调用的
//HAL_Init();
//SystemClock_Config();
//MX_USART1_UART_Init();
HAL_Init();SystemClock_Config(); 可以直接放到rt_hw_board_init（）里面调用，串口初始化因为我们重写了，且通过INIT_BOARD_EXPORT(uart_init);导出到初始化列表了，就可以不用再写到rt_hw_board_init（）里面。最终rt_hw_board_init（）代码修改如下：

void rt_hw_board_init()
{
    /* System Clock Update */
    //SystemCoreClockUpdate();
    HAL_Init();
	  SystemClock_Config();
    /* System Tick Configuration */
    _SysTick_Config(HAL_RCC_GetSysClockFreq() / RT_TICK_PER_SECOND);

    /* Call components board initial (use INIT_BOARD_EXPORT()) */
#ifdef RT_USING_COMPONENTS_INIT
    rt_components_board_init();
#endif

#if defined(RT_USING_USER_MAIN) && defined(RT_USING_HEAP)
//      rt_system_heap_init(rt_heap_begin_get(), rt_heap_end_get()); //使用指定数组大小分配内存堆	
      rt_system_heap_init((void *)HEAP_BEGIN, (void *)HEAP_END);    //最大化利用动态内存堆
#endif
}

默认生成的rt_hw_board_init（）是采用指定数组的方式分配内存堆，这种方式没有物尽其用，浪费了部分内存，所以利用链接符号自己定义要使用的堆起始和结束地址，把SRAM可用空间榨干，如下：

/*最大化使用动态内存堆*/
#ifdef __ICCARM__
// Use *.icf ram symbal, to avoid hardcode.
extern char __ICFEDIT_region_IRAM1_end__;
#define STM32_SRAM_END          &__ICFEDIT_region_IRAM1_end__
#else
#define STM32_SRAM_SIZE         192    /* 根据自己的MCU不同修改,F429的SRAM大小192K */
#define STM32_SRAM_END          (0x20000000 + STM32_SRAM_SIZE * 1024)/* 根据自己的MCU不同修改 */
#endif
 
#ifdef __CC_ARM
extern int Image$$RW_IRAM1$$ZI$$Limit;
#define HEAP_BEGIN    ((void *)(&Image$$RW_IRAM1$$ZI$$Limit))
#elif __ICCARM__
#pragma section="HEAP"
#define HEAP_BEGIN    (__segment_end("HEAP"))
#else
extern int __bss_end;
#define HEAP_BEGIN    (&__bss_end)
#endif
 
#define HEAP_END                STM32_SRAM_END

编译通过，help命令测试：
在这里插入图片描述
再用free命令查看下内存使用情况：

可以看到F429的192KSRAM基本都用上了，一个满意的RTT模板工程OK了，收工。

总结

CUBEMX＋MDK还是我的最爱！用的就是爽。

海水与火焰

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
2021-06-02

RTthread再学习记录前言一、RTthread移植代码自动生成方案二、使用CUBEMX在STM32F4上移植RTT1.官方提供的教程2.解决RTT移植的一些细节问题总结提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、RTthread移植代码自动生成方案二、使用CUBEMX在STM32F4上移植RTT1.官方提供的教程2.解决RTT移植的一些细节问题总结前言本人之前很少写技术博客，一是因为自己懒，二是因为在公司做项目涉及的一些东西不方便写在网上，不过因为最近
复制链接

扫一扫