#define BSP_USING_UART
#define BSP_USING_UART1
#define BSP_UART1_RX_USING_DMA
#define BSP_USING_UART2
#define BSP_UART2_RX_USING_DMA
#define BSP_USING_UART4
#define BSP_UART4_RX_USING_DMA

/*
 * 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;
}