RTthread 使用CAN通讯硬件端口怎么配置的？

发布于 2021-06-02 22:42:38 浏览：2103 订阅该版

之前一直用裸机，最近才开始用rtthread，看了drv_can.c的程序，关于设置硬件端口的地方不是太明白，请各位大神指导一下。
rt_err_t rt_hw_can_register(struct rt_can_device    *can,
                            const char              *name,
                            const struct rt_can_ops *ops,
                            void                    *data)
{
    struct rt_device *device;
    RT_ASSERT(can != RT_NULL);

device = &(can->parent);

device->type        = RT_Device_Class_CAN;
    device->rx_indicate = RT_NULL;
    device->tx_complete = RT_NULL;
#ifdef RT_CAN_USING_HDR
    can->hdr            = RT_NULL;
#endif
    can->can_rx         = RT_NULL;//这地方是配置什么的？
    can->can_tx         = RT_NULL;//
    rt_mutex_init(&(can->lock), "can", RT_IPC_FLAG_PRIO);
#ifdef RT_CAN_USING_BUS_HOOK
    can->bus_hook       = RT_NULL;
#endif /*RT_CAN_USING_BUS_HOOK*/

#ifdef RT_USING_DEVICE_OPS
    device->ops         = &can_device_ops;
#else
    device->init        = rt_can_init;
    device->open        = rt_can_open;
    device->close       = rt_can_close;
    device->read        = rt_can_read;
    device->write       = rt_can_write;
    device->control     = rt_can_control;
#endif
    can->ops            = ops;

can->status_indicate.ind  = RT_NULL;
    can->status_indicate.args = RT_NULL;
    rt_memset(&can->status, 0, sizeof(can->status));

device->user_data   = data;

can->timerinitflag  = 0;
    rt_timer_init(&can->timer,
                  name,
                  cantimeout,
                  (void *)can,
                  can->config.ticks,
                  RT_TIMER_FLAG_PERIODIC);
    /* register a character device */
    return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR);
}
有没有配置好的代码上来学习一下。参考着代码理解的更清楚一下。谢谢大家！

3 个回答

小小李sunny 2021-06-02

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

冰棒棍儿 2021-06-03

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

小小李sunny 2021-06-03

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

冰棒棍儿 2021-06-03

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

@小小李sunny 我现在没看懂硬件端口和系统是怎能连接的啊！我有两个CAN，从哪里看是连那个端口的？
我现在直接用裸机的方法先把端口配置好
```c
    //struct rt_can_device *can1_drv;	
	GPIO_InitPara GPIO_InitStruct;
    /* enable CAN clock */
    rcu_periph_clock_enable(RCU_CAN0);
    //rcu_periph_clock_enable(RCU_CAN1);
    rcu_periph_clock_enable(RCU_GPIOA);
    //rcu_periph_clock_enable(RCU_GPIOD);
    rcu_periph_clock_enable(RCU_AF);
    
    /* configure CAN0 GPIO */
	GPIO_InitStruct.GPIO_Mode=GPIO_MODE_AF_OD;//GPIO_MODE_IN_FLOATING;
	GPIO_InitStruct.GPIO_Speed=GPIO_SPEED_50MHZ;
	GPIO_InitStruct.GPIO_Pin=GPIO_PIN_11;//RX
	GPIO_Init(GPIOA,&GPIO_InitStruct);
	GPIO_InitStruct.GPIO_Mode=GPIO_MODE_AF_PP;
	GPIO_InitStruct.GPIO_Speed=GPIO_SPEED_50MHZ;
	GPIO_InitStruct.GPIO_Pin=GPIO_PIN_12;//TX
	GPIO_Init(GPIOA,&GPIO_InitStruct);	
	
	drv_can1.config.baud_rate=CAN250kBaud;
	drv_can1.config.maxhdr=3;/*如果使用硬件过滤，则开启RT_CAN_USING_HDR, maxhdr 为Can控制器过滤表的数量*/
	drv_can1.config.mode=RT_CAN_MODE_NORMAL;/*正常模式*/
	drv_can1.config.msgboxsz=2;/* Can接收邮箱缓冲数量，本驱动在软件层开辟msgboxsz个接收邮箱*/
	drv_can1.config.privmode=RT_CAN_MODE_NOPRIV;/*配置Can driver的优先级模式*/
	//config.reserved
	drv_can1.config.sndboxnumber=2;/*can 发送通道数量，该配置为Can控制器实际的发送通道数量*/
	drv_can1.config.ticks=20;/*配置Can driver timer周期*/

rt_hw_can_register(&drv_can1,
                            "can1",
                            drv_can1.ops,
                             &drv_can1);
```
现在驱动挂上去了，用的是网站上的例子，但是运行到这下面这句就死那了
```c        
    res = rt_device_open(can_dev, RT_DEVICE_FLAG_INT_TX|RT_DEVICE_FLAG_INT_RX);  /* 以中断接收及发送方式打开 CAN 设备 */
```
```
msh />can_sample
psr: 0x60000000
r00: 0x20000734
r01: 0x20000788
r02: 0x200057b8
r03: 0x20000714
r04: 0x20000734
r05: 0x20000734
r06: 0x00000000
r07: 0x00000001
r08: 0x200074bc
r09: 0x0000000a
r10: 0xdeadbeef
r11: 0xdeadbeef
r12: 0x00000000
 lr: 0x08001165
 pc: 0x200057b8
hard fault on thread: tshell

thread   pri  status      sp     stack size max used left tick  error
-------- ---  ------- ---------- ----------  ------  ---------- ---
led1       3  suspend 0x0000007c 0x00000100    48%   0x00000014 000
led0       3  suspend 0x0000007c 0x00000100    48%   0x00000014 000
tshell    20  running 0x00000138 0x00001000    12%   0x00000007 000
tidle0    31  ready   0x00000040 0x00000100    34%   0x00000005 000
timer      4  suspend 0x00000058 0x00000200    17%   0x0000000a 000
usage fault:
SCB_CFSR_UFSR:0x02 INVSTATE
```

小小李sunny 2021-06-04

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

请登录后再发布评论，点击登录

追加回复

zhkag 2021-06-04

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

redoc 2021-06-04

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

```c
/*
 * Copyright (c) 2019-2020, redoc
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2020-03-30     redoc        the first version
 */

#define LOG_TAG      "can"
#define LOG_LVL      LOG_LVL_DBG

#include <rtthread.h>
#include "rtdevice.h"
#include "thread_can.h"
#include "ulog.h"

#define CAN_DEV_NAME       "can1"

#define CAN1_CONFIG         \
{                           \
        CAN500kBaud,        \
        RT_CANMSG_BOX_SZ,   \
        RT_CANSND_BOX_NUM,  \
        RT_CAN_MODE_NORMAL, \
};

static rt_sem_t sem_can_rx;    
static rt_sem_t sem_can_tx;       
static rt_device_t can_dev;

static rt_err_t can_rx_call(rt_device_t dev, rt_size_t size)
{
    rt_sem_release(sem_can_rx);

return RT_EOK;
}

static void can_rx_thread(void *parameter)
{
    rt_err_t res;
    struct rt_can_msg rxmsg = {0};

#ifdef RT_CAN_USING_HDR
   
    struct rt_can_filter_item items[2] =
    {
        // id, ide, rtr, mode, mask, hdr
        {0x30 << 18,  0, 0, 0, (((rt_uint32_t)0x7f8 << 21)| 6), 0},
        {0x40 << 18,  0, 0, 1, (((rt_uint32_t)0x7ff << 21)| 6), 1},
    };
    
    struct rt_can_filter_config cfg = {2, 1, items};
   
    res = rt_device_control(can_dev, RT_CAN_CMD_SET_FILTER, &cfg);
    RT_ASSERT(res == RT_EOK);
#endif

rt_thread_mdelay(1000);

while (1)
    {
        rxmsg.hdr = -1;
        if(RT_EOK == rt_sem_take(sem_can_rx, 20))
        {
            rt_device_read(can_dev, 0, &rxmsg, sizeof(rxmsg));
     
    //        rt_kprintf("ID:%x Len:%d Data:", rxmsg.id, rxmsg.len);
    //        for (int i = 0; i < 8; i++) 
    //        {
    //            rt_kprintf("%2x ", rxmsg.data[i]);
    //        }

//        rt_kprintf("\r\n");
            
            //  解析数据 id data len
            //can_process_unpack(rxmsg.id, rxmsg.data, rxmsg.len);
        }
    }
}

int can_send(uint16_t can_id, uint8_t *buf, uint8_t len)
{
    struct rt_can_msg msg = {0};
    uint16_t size;
    
    rt_sem_take(sem_can_tx, RT_WAITING_FOREVER);
    
    msg.id = can_id;              
    msg.ide = RT_CAN_STDID;    
    msg.rtr = RT_CAN_DTR;      
    msg.len = len;        
   
    rt_memcpy(msg.data, buf, len);

size = rt_device_write(can_dev, 0, &msg, sizeof(msg));
    if (size == 0)
    {
        rt_kprintf("can dev write data failed!\n");
    }

rt_sem_release(sem_can_tx);
    
    return size;
}

int thread_can_init(void)
{
    rt_err_t res;
    rt_thread_t thread;
    struct can_configure cfg = CAN1_CONFIG;
    
    can_dev = rt_device_find(CAN_DEV_NAME);
    if (!can_dev)
    {
        rt_kprintf("find %s failed!\n", CAN_DEV_NAME);
        return -RT_ERROR;
    }

sem_can_rx = rt_sem_create("can_rx", 0, RT_IPC_FLAG_FIFO);
    sem_can_tx = rt_sem_create("can_tx", 1, RT_IPC_FLAG_FIFO);

res = rt_device_open(can_dev, RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_TX | RT_DEVICE_FLAG_INT_RX);
    RT_ASSERT(res == RT_EOK);

rt_device_control(can_dev, RT_DEVICE_CTRL_CONFIG, &cfg);
    
    rt_device_set_rx_indicate(can_dev, can_rx_call);

thread = rt_thread_create("can_rx", can_rx_thread, RT_NULL, 2048, 16, 100);
    if (thread != RT_NULL)
    {
        rt_thread_startup(thread);
    }
    else
    {
        log_e("create can_rx thread failed!");
    }

return res;
}
```