rtthread开发笔记心得

一env使用

1.1：使用env构建rtthread项目：安装env_released_1.1.1，打开env命令终端可以对rtthread的项目进行配置，在env中使用menuconfig命令进行图形界面的选择配置，menuconfig除了系统自带的根目录，外设的设备添加选项由项目的kconfig配置得到，将kconfig添加想添加的外设，使用menuconfig配置后，保存，会把相应的配置更新到.config文件中，然后使用命令scons --target=mdk5（scons --target=xxx）更新到项目工程中。

1.2：打开项目工程，在rtconfig.h中可以得到配置好的头文件包含了，相应的rtthread中的外设支持头文件，源文件可以在rtdevice.h中查看，相应的源文件，头文件加入工程需要在rtconfi.h配置相应的头文件。Menuconfig结合kconfig可以完成这一步。

1.3：当系统是不能支持env的，也就是项目工程不需要SConscript脚本配置的情况下使用手动添加即可。（另项目工程的各目录下的配置脚本是各目录下的SConscript脚本，开发时候可以在相应的脚本中添加用户需要的配置）其中env工具要求项目工程必须有bsp目录（即板级支持包，里面是不同芯片板卡系列的实现工程）。其执行添加在项目工程所在目录下，查找bsp。

2：工程更改基本配置：

2.1：kconfig，即rtconfig 的头文件配置就可以直接加载3步骤的东西

2.2：其中基本要配置的script有 ：E:\rtt\rt-thread-master - 1\bsp\gd32303e-eval\drivers这个目录下的script是向工程自动添加上相应为外设源文件（用户添加的）

E:\rtt\rt-thread-master - 1\bsp\gd32303e-eval\Libraries 下的SConscript是配置工程的开发环境的脚本，比如更改hd.s等

2.3：然后rtthread提供的外设结构体在E:\rtt\rt-thread-master - 1\components\drivers下

 

 

二相应的添加外设操作（env）：

 

三用户完成外设驱动层（最主要）

1：Rtthread是一个分层架构的系统，用户需要对接rtthread外设并将其提供的ops结构体进行实现，之后就可以开始使用和驱动外设了，

实现这个ops的源代码可以参考各芯片系列的。其中主要的原因就是各外设需要挂载到总线上，调用注册函数就进行挂载，外部即可使用。

2：其中ops基本的结构会包含init，control，write，read这几部分，需要相应的去实现，二各外设基本分成两部分：1是类似spi这种有总线的外设，其最大的区别就是可以在一个spi总线上链接很多的设备，各设备的驱动芯片不同，导致需要添加不同的芯片驱动，2是类似串口，定时器这种的，基本都是开始初始化一个设备就可以进行使用。所以两者之间的ops结构体实现的方式是有些不同的。

Spi例子讲解：

 

#include "drv_spi.h"

#include "gd32f30x.h"

#include <rtthread.h>

 

/* private rt-thread spi ops function */

static rt_err_t configure(struct rt_spi_device* device, struct rt_spi_configuration* configuration);

static rt_uint32_t xfer(struct rt_spi_device* device, struct rt_spi_message* message);

 

static struct rt_spi_ops gd32_spi_ops =   //实现rt_spi_ops接口，主要实现里面的成员属性

{

    configure,

    xfer

};

//主要用于配置spi

static rt_err_t configure(struct rt_spi_device* device, struct rt_spi_configuration* configuration)

{

    spi_parameter_struct spi_init_struct;

 

    rt_uint32_t spi_periph = (rt_uint32_t)device->bus->parent.user_data;

 

    RT_ASSERT(device != RT_NULL);

    RT_ASSERT(configuration != RT_NULL);

 

    if(configuration->data_width <= 8)

    {

        spi_init_struct.frame_size = SPI_FRAMESIZE_8BIT;

    }

    else if(configuration->data_width <= 16)

    {

        spi_init_struct.frame_size = SPI_FRAMESIZE_16BIT;

    }

    else

    {

        return RT_EIO;

    }

 

    {

        rcu_clock_freq_enum spi_src;

        rt_uint32_t spi_apb_clock;

        rt_uint32_t max_hz;

 

        max_hz = configuration->max_hz;

 

        if (spi_periph == SPI1 || spi_periph == SPI2)

        {

            spi_src = CK_APB1;   //×î´ó60M

        }

        else

        {

            spi_src = CK_APB2;

        }

        spi_apb_clock = rcu_clock_freq_get(spi_src);

 

        if(max_hz >= spi_apb_clock/2)   //2·ÖƵ

        {

            spi_init_struct.prescale = SPI_PSC_2;

        }

        else if (max_hz >= spi_apb_clock/4)

        {

            spi_init_struct.prescale = SPI_PSC_4;

        }

        else if (max_hz >= spi_apb_clock/8)

        {

            spi_init_struct.prescale = SPI_PSC_8;

        }

        else if (max_hz >= spi_apb_clock/16)

        {

            spi_init_struct.prescale = SPI_PSC_16;

        }

        else if (max_hz >= spi_apb_clock/32)

        {

            spi_init_struct.prescale = SPI_PSC_32;

        }

        else if (max_hz >= spi_apb_clock/64)

        {

            spi_init_struct.prescale = SPI_PSC_64;

        }

        else if (max_hz >= spi_apb_clock/128)

        {

            spi_init_struct.prescale = SPI_PSC_128;

        }

        else

        {

            /*  min prescaler 256 */

            spi_init_struct.prescale = SPI_PSC_256;

        }

    } /* baudrate */

    

    switch(configuration->mode & RT_SPI_MODE_3)

    {

    case RT_SPI_MODE_0:

        spi_init_struct.clock_polarity_phase = SPI_CK_PL_LOW_PH_1EDGE;  

        break;

    case RT_SPI_MODE_1:

        spi_init_struct.clock_polarity_phase = SPI_CK_PL_LOW_PH_2EDGE;

        break;

    case RT_SPI_MODE_2:

        spi_init_struct.clock_polarity_phase = SPI_CK_PL_HIGH_PH_1EDGE;

        break;

    case RT_SPI_MODE_3:

        spi_init_struct.clock_polarity_phase = SPI_CK_PL_HIGH_PH_2EDGE;

        break;

    }

    

    /* MSB or LSB */

    if(configuration->mode & RT_SPI_MSB)

    {

        spi_init_struct.endian = SPI_ENDIAN_MSB;   //zege

    }

    else

    {

        spi_init_struct.endian = SPI_ENDIAN_LSB;

    }

 

    spi_init_struct.trans_mode = SPI_TRANSMODE_FULLDUPLEX;

    spi_init_struct.device_mode = SPI_MASTER;

    spi_init_struct.nss = SPI_NSS_SOFT;

 

    spi_init(spi_periph, &spi_init_struct);

 

    spi_crc_off(spi_periph);    //spi_crc_polynomial_set(spi_periph,7); spi_crc_on(spi_periph);

   

 

    spi_enable(spi_periph);

 

    return RT_EOK;

};

//实现发送接受接口

static rt_uint32_t xfer(struct rt_spi_device* device, struct rt_spi_message* message)  

{

    rt_base_t gd32_cs_pin = (rt_base_t)device->parent.user_data;

    rt_uint32_t spi_periph = (rt_uint32_t)device->bus->parent.user_data;

    struct rt_spi_configuration * config = &device->config;

 

    RT_ASSERT(device != NULL);

    RT_ASSERT(message != NULL);

 

    /* take CS */

if(message->cs_take)

{  

 gpio_bit_reset(GPIOA,GPIO_PIN_4);

    }

 

    {

        if(config->data_width <= 8)

        {

            const rt_uint8_t * send_ptr = message->send_buf;

            rt_uint8_t * recv_ptr = message->recv_buf;

            rt_uint32_t size = message->length;

            

            DEBUG_PRINTF("spi poll transfer start: %d\n", size);

 

            while(size--)

            {

                rt_uint8_t data = 0xFF;

 

                if(send_ptr != RT_NULL)

                {

                    data = *send_ptr++;

                }

                

                while(RESET == spi_i2s_flag_get(spi_periph, SPI_FLAG_TBE));

                spi_i2s_data_transmit(spi_periph, data);

 

                while(RESET == spi_i2s_flag_get(spi_periph, SPI_FLAG_RBNE));

                data = spi_i2s_data_receive(spi_periph);

 

                if(recv_ptr != RT_NULL)

                {

                    *recv_ptr++ = data;

                }

            }

        }

        else if(config->data_width <= 16)

        {

            const rt_uint16_t * send_ptr = message->send_buf;

            rt_uint16_t * recv_ptr = message->recv_buf;

            rt_uint32_t size = message->length;

            while(size--)

            {

                rt_uint16_t data = 0xFF;

 

                if(send_ptr != RT_NULL)

                {

                    data = *send_ptr++;

                }

 

                while(RESET == spi_i2s_flag_get(spi_periph, SPI_FLAG_TBE));

                spi_i2s_data_transmit(spi_periph, data);

 

                while(RESET == spi_i2s_flag_get(spi_periph, SPI_FLAG_RBNE));

                data = spi_i2s_data_receive(spi_periph);

 

                if(recv_ptr != RT_NULL)

                {

                    *recv_ptr++ = data;

                }

            }

        }

    }

 

    /* release CS */

    if(message->cs_release)

    {

gpio_bit_set(GPIOA,GPIO_PIN_4);

    }

    return message->length;

};

 

 

int gd32_hw_spi_init(void)   

{

    int result = 0;

#ifdef RT_USING_SPI0

    static struct rt_spi_bus spi_bus0;

    spi_bus0.parent.user_data = (void *)SPI0;

 

    result = rt_spi_bus_register(&spi_bus0, "spi0", &gd32_spi_ops);       

rcu_periph_clock_enable(RCU_GPIOA|RCU_AF);                          

    rcu_periph_clock_enable(RCU_SPI0);

    /* SPI0_SCK(PA5), SPI0_MISO(PA6) and SPI0_MOSI(PA7) GPIO pin configuration */

 

    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_5 | GPIO_PIN_7);   

#endif

    return result;

}

INIT_BOARD_EXPORT(gd32_hw_spi_init);  

#endif

以上代码用于向系统注册spi总线，方便外部挂载设备

 

外部挂载设备可以如下调用：

 

#define SPI_BUS_NAME                  "spi0"   //设备挂载的总线名称

#define SPI_dac104s085_DEVICE_NAME     "spi01"   //随便命名

 

#define CS_PIN   29           //根据不同芯片的引脚号去选择

 

struct stm32_hw_spi_cs

{

    rt_uint32_t pin;

};

 

static struct rt_spi_device spi_dev_dac104s085;

static struct stm32_hw_spi_cs  spi_cs;

 

rt_err_t dac104s085_write_data(const rt_uint16_t *data,const int lendth)

{

    rt_size_t len;

    len = rt_spi_send(&spi_dev_dac104s085, data, lendth);

    if (len != lendth)

    {

        OLED_TRACE("dac104s085_write_data error. %d\r\n",len);

        return -RT_ERROR;

    }

    else       

    {

        return RT_EOK;

    }

}

 

static int rt_hw_dac104s085_config(void)

{

rt_err_t res;

 

    spi_cs.pin = CS_PIN;

    rt_pin_mode(spi_cs.pin, GPIO_MODE_OUT_PP);   

rt_pin_write(CS_PIN, PIN_HIGH);

    res = rt_spi_bus_attach_device(&spi_dev_dac104s085, SPI_dac104s085_DEVICE_NAME, SPI_BUS_NAME, (void*)&spi_cs);

    if (res != RT_EOK)

    {

        OLED_TRACE("rt_spi_bus_attach_device!\r\n");

        return res;

    }

 

    /* config spi */

    {

        struct rt_spi_configuration cfg;

        cfg.data_width = 16;

        cfg.mode =  RT_SPI_MODE_1 | RT_SPI_MSB;

        cfg.max_hz = 40 * 1000 *1000; /* 40M,SPI*/

 

        rt_spi_configure(&spi_dev_dac104s085, &cfg);

    }

    return RT_EOK;

}

 

static int rt_hw_dac104s0835_init(void)

{

rt_hw_dac104s085_config();

    return 0;

}

INIT_PREV_EXPORT(rt_hw_dac104s0835_init);

 

定时器的例子可以下载我上传的资源。

https://download.csdn.net/download/lilijianqun/11570745

 

四驱动流程

1外设的初始化在完整的rtthread的工程中直接使用INIT_BOARD_EXPORT（）命令导出去进行自动初始化操作，这个命令调用的是rtthread中的自动初始化功能，

2启动流程

 

$Sub$$main()这个是系统启动最先调用的函数，之后调用rtthread_startup()函数去调用各种必要初始化条件，这些基本重要的函数都在components.c文件中可以查到

 

五开发：

线程，信号量，信号队列，等看文档开发rtrthread编程指南

 

 

六移植：

最主要的在于板卡的支持，其中主要是时钟树的驱动（系统时钟，滴答定时器）和中断的处理

{contextdrv.s中

中断主要是实现上下文切换：

{

“这几个的实现可以参考rtrthread编程指南”

rt_hw_context_switch_to() 

rt_hw_context_switch() 

rt_hw_context_switch_interrupt()

}

PendSV_Handler

rt_hw_interrupt_disable   关中断

rt_hw_interrupt_enable   开中断

rt_hw_interrupt_thread_switch

}