关于RTT的SPI总线的使用问题

发布于 2015-06-03 15:57:52 浏览：2912 订阅该版

我使用的是STM32F10x平台。
并在`bsp/stm32f107`下找到了驱动。
发现例程只是调用` rt_hw_spi_init();`对spi进行了初始化，似乎并未使用。

于是在官方wiki下搜索spi,找到了如下使用方式：

```c
message.length = 1; 
   message.recv_buf = &value; 
   message.send_buf = &data; 
   message.cs_release = 0; 
   message.cs_take = 0; 
   message.next = RT_NULL; 
   rt_spi_transfer_message(device①,&message);
```

追踪`rt_spi_transfer_message`发现调用了`device->bus->ops->configure(device②, &device->config);`
进一步追踪看到了这样一个式子`struct stm32_spi_bus * stm32_spi_bus = (struct stm32_spi_bus *)device③->bus;`
而后发现`stm32_spi_bus->SPI`

不解的是：
①处的device是`struct rt_spi_device  *device`，
所以`device->bus`应该是`struct rt_spi_bus *`，

而例程通过一个强制转换直接将其转换为了`struct stm32_spi_bus *`，
并顺理成章的使用`stm32_spi_bus->SPI`，那么这个device的实例到底是什么？
其实根本问题是如何通过一个rt_spi_device实例找到stm32_spi_bus。

目前只知道`rt_spi_device->rt_spi_bus/stm32_spi_bus->rt_spi_bus`。
以下是几个结构体的定义：
```c
struct rt_spi_device
{
    struct rt_device parent;
    struct rt_spi_bus *bus;

struct rt_spi_configuration config;
};
struct rt_spi_bus
{
    struct rt_device parent;
    const struct rt_spi_ops *ops;

struct rt_mutex lock;
    struct rt_spi_device *owner;
};
struct stm32_spi_bus
{
    struct rt_spi_bus parent;
    SPI_TypeDef * SPI;
#ifdef SPI_USE_DMA
    DMA_Channel_TypeDef * DMA_Channel_TX;
    DMA_Channel_TypeDef * DMA_Channel_RX;
    uint32_t DMA_Channel_TX_FLAG_TC;
    uint32_t DMA_Channel_TX_FLAG_TE;
    uint32_t DMA_Channel_RX_FLAG_TC;
    uint32_t DMA_Channel_RX_FLAG_TE;
#endif /* SPI_USE_DMA */
};
```

下载附件
- [C语言面向对象思想.doc](https://oss-club.rt-thread.org/uploads/5208_016b6935ff458e8142bd906a0f93d1d3.txt)

5 个回答

bernard 2015-06-03

这家伙很懒，什么也没写！

ck1994 2015-06-03

这家伙很懒，什么也没写！

pangwei 2015-06-04

这家伙很懒，什么也没写！

继承性是子类自动共享父类之间数据和方法的机制。它由类的派生功能体现。一个类直接继承其它类的全部描述，同时可修改和扩充。继承具有传递性。继承分为单继承（一个子类只有一父类）和多重继承（一个类有多个父类，当前RT-Thread的对象系统不能支持）。类的对象是各自封闭的，如果没继承性机制，则类对象中数据、方法就会出现大量重复。继承不仅支持系统的可重用性，而且还促进系统的可扩充性
```c
 /* 父类 */
    struct parent_class
    {
        int a, b;
        char *str;
    };

/* 继承于父类的子类 */
    struct child_class
    {
        struct parent_class p;
        int a, b;
    };

/* 操作示例函数*/
    void func()
    {
        struct child_class obj, *obj_ptr; /* 子类对象及指针 */
        struct parent_class *parent_ptr; /* 父类指针 */

obj_ptr = &obj;
        /* 取父指针 */
        parent_ptr = (struct parent_class*) &obj;

/* 可通过转换过类型的父类指针访问相应的属性 */
        parent_ptr->a = 1;
        parent_ptr->b = 5;

/* 子类属性的操作 */
        obj_ptr->a = 10;
        obj_ptr->b = 100;
    }
```
在上面代码中，注意child_class结构中第一个成员p，这种声明方式代表child_class类型的数据中开始的位置包含一个parent_class类型的变量。

在函数func中obj是一个child_class对象，正像这个结构类型指示的，它前面的数据应该包含一个parent_class类型的数据。在第21行的强制类型赋值中parent_ptr指向了obj变量的首地址，也就是obj变量中的p对象。

好了，现在parent_ptr指向的是一个真真实实的parent类型的结构，那么可以按照parent的方式访问其中的成员，当然也包括可以使用和parent结构相关的函数来处理内部数据，因为一个正常的，正确的代码，它是不会越界访问parent结构体以外的数据。

经过这基本的结构体层层相套包含，对象简单的继存关系就体现出来了：父对象放于数据块的最前方，代码中可以通过强制类型转换获得父对象指针。