一、源码下载

1、git下载

点击我下载

2、csdn下载

自己上传的点击下载

二、源码移植

我自己是使用rt-thread操作系统移植的。但是不局限与操作系统，裸机也可以。

1、首先将源码加入到工程

在这里插入图片描述

2、分别实现一个内存的分配与释放函数，他是一个指针函数，原型为`typedef void* (CanardMemoryAllocate)(CanardInstance ins, size_t amount);`

static void* mem_allocate(CanardInstance* const canard, const size_t amount)
{(void) canard;return rt_malloc(amount);
}

static void mem_free(CanardInstance* const canard, void* const pointer)
{(void) canard;rt_free(pointer);
}

3、初始化canard

void slave_comm_init()
{canard = canardInit(&mem_allocate, &mem_free);canard.node_id = savePara.id; txQueue = canardTxInit(1536,  CANARD_MTU_CAN_CLASSIC);  // Set MTU = 64 bytes. There is also CANARD_MTU_CAN_CLASSIC.	
}

canard.node_id 设置本机id
canardTxInit(1536, CANARD_MTU_CAN_CLASSIC); 初始化发送队列，1536为大小。CANARD_MTU_CAN_CLASSIC表示使用的是普通的can，数据最大为8个字节，CANARD_MTU_CAN_FD表示使用的是can fd。

3、实现发送函数

void slave_comm_tx_process()
{for (const CanardTxQueueItem* ti = NULL; (ti = canardTxPeek(&txQueue)) != NULL;)  // Peek at the top of the queue.{if ((0U == ti->tx_deadline_usec) || (ti->tx_deadline_usec > rt_tick_get_millisecond()*1000))  // Check the deadline.{if (!slave_send_ext(ti->frame.extended_can_id,(void *)ti->frame.payload,ti->frame.payload_size))               // Send the frame over this redundant CAN iface.{break;                             // If the driver is busy, break and retry later.}}// After the frame is transmitted or if it has timed out while waiting, pop it from the queue and deallocate:canard.memory_free(&canard, canardTxPop(&txQueue, ti));}		
}

canard协议将发送的包处理完后会写入到队列中，canardTxPeek(&txQueue))从队列中取出数据，slave_send_ext(ti->frame.extended_can_id,(void *)ti->frame.payload,ti->frame.payload_size))为硬件发送函数，调用can发送。注意：UAVCAN使用的是扩展帧id。
硬件发送函数为：

rt_inline uint8_t slave_send_ext(uint32_t id,uint8_t *sendBuf,uint8_t len)
{struct rt_can_msg txMsg = {0};txMsg.id = 	id;txMsg.ide = RT_CAN_EXTID;txMsg.rtr = RT_CAN_DTR;txMsg.len = len;for(rt_uint8_t i=0;i<len;i++){txMsg.data[i] = sendBuf[i];}return rt_device_write(slaveDev,0,&txMsg,sizeof(txMsg));}

RT_CAN_EXTID表示使用扩展帧

4、实现can硬件接收处理函数

void slave_comm_rx_process()
{CanardRxTransfer transfer;CanardFrame receivedFrame;struct rt_can_msg canRxMsg = {0};uint32_t rxTimestampUsec;int8_t result;while(rt_mq_recv(&slave_rec_msgq,&canRxMsg,sizeof(canRxMsg),RT_WAITING_NO) == RT_EOK){receivedFrame.extended_can_id = canRxMsg.id;receivedFrame.payload_size = canRxMsg.len;receivedFrame.payload = canRxMsg.data;rxTimestampUsec = rt_tick_get_millisecond()*1000;result = canardRxAccept(&canard,rxTimestampUsec,          // When the frame was received, in microseconds.&receivedFrame,            // The CAN frame received from the bus.0,  // If the transport is not redundant, use 0.&transfer,NULL);if (result < 0){// An error has occurred: either an argument is invalid or we've ran out of memory.// It is possible to statically prove that an out-of-memory will never occur for a given application if// the heap is sized correctly; for background, refer to the Robson's Proof and the documentation for O1Heap.// Reception of an invalid frame is NOT an error.}else if (result == 1){void process_received_transfer(const uint8_t index,CanardRxTransfer* const transfer);process_received_transfer(0, &transfer);  // A transfer has been received, process it.canard.memory_free(&canard, transfer.payload);                  // Deallocate the dynamic memory afterwards.}else{// Nothing to do.// The received frame is either invalid or it's a non-last frame of a multi-frame transfer.// Reception of an invalid frame is NOT reported as an error because it is not an error.}}	
}

实现方法是，在can的中断中接收到数据放入slave_rec_msgq队列，

	struct rt_can_msg rxMsg = {0};rt_device_read(slaveDev,0,&rxMsg,sizeof(rxMsg));rt_mq_send(&slave_rec_msgq, &rxMsg, sizeof(rxMsg));

然后协议从队列中读取数据处理。
将can数据转为canard支持的数据类型。

		receivedFrame.extended_can_id = canRxMsg.id;receivedFrame.payload_size = canRxMsg.len;receivedFrame.payload = canRxMsg.data;

当协议接收到完整的一帧数据后返回result等于1，自己处理接收到的数据。

process_received_transfer(0, &transfer);  // A transfer has been received, process it.

实现为：

void process_received_transfer(const uint8_t index,CanardRxTransfer* const transfer)
{LOG_D("slave rec id:%d size:%d",transfer->metadata.remote_node_id,transfer->payload_size);if(transfer->metadata.remote_node_id == canard.node_id){slavePackDef *p = (slavePackDef *)transfer->payload;recCmd = p->packCmd;}}

数据保存在transfer->payload中。执行完毕后释放内存：canard.memory_free(&canard, transfer.payload); 。

5、订阅消息

在canard协议中消息有三种类型，分别是： CanardTransferKindMessage``CanardTransferKindResponse 、CanardTransferKindRequest
区别在于：
CanardTransferKindMessage ：广播，从发布者到所有订阅者。
CanardTransferKindResponse：点对点，从服务器到客户端。
CanardTransferKindRequest：点对点，从客户端到服务器。

一般来说从机为服务端，主机为客户端。

void slave_control_init()
{(void) canardRxSubscribe(&canard,   // Subscribe to an arbitrary service response.CanardTransferKindResponse,  // Specify that we want service responses, not requests.SLAVE_RESPONSE_PORT_ID,       // The Service-ID whose responses we will receive.1536,      // The extent (see above).CANARD_DEFAULT_TRANSFER_ID_TIMEOUT_USEC,&responseSubscription);}

以上订阅了一个CanardTransferKindResponse类型的消息，Service-ID为SLAVE_RESPONSE_PORT_ID，

#define SLAVE_RESPONSE_PORT_ID 123

函数原型为：

int8_t canardRxSubscribe(CanardInstance* const       ins,const CanardTransferKind    transfer_kind,const CanardPortID          port_id,const size_t                extent,const CanardMicrosecond     transfer_id_timeout_usec,CanardRxSubscription* const out_subscription);

参数解析：
ins：canard的一个实例，就是上面初始化的那个变量。
transfer_kind：消息类型，上面说的三个。
port_id：消息id。
extent：定义了传输有效载荷存储器缓冲器的大小。
transfer_id_timeout_usec：默认传输ID超时值定义。
out_subscription：如果已根据请求创建新订阅，则返回值为1。
如果在调用函数时存在此类订阅，则返回值为0。在这种情况下，终止现有订阅，然后在其位置创建新订阅。挂起的传输可能会丢失。
如果任何输入参数无效，则返回值为否定的无效参数错误。

三、应用层数据发送

static void send_data()
{static uint8_t messageTransferId = 0; const CanardTransferMetadata transferMetadata = {.priority       = CanardPriorityNominal,.transfer_kind  = CanardTransferKindResponse,.port_id        = SLAVE_RESPONSE_PORT_ID,     .remote_node_id = id,      .transfer_id    = messageTransferId,};uint8_t sendBuf[100];for(uint8_t i=0;i<sizeof(sendBuf);i++){sendBuf[i] = i;}++messageTransferId; transmission on this subject.int32_t result = canardTxPush(&txQueue,              &canard,0,   &transferMetadata,sizeof(sendBuf),                  sendBuf);if (result < 0){LOG_W("slave cmd send failed!");}	
}

需要注意的是：

	const CanardTransferMetadata transferMetadata = {.priority       = CanardPriorityNominal,.transfer_kind  = CanardTransferKindResponse,.port_id        = SLAVE_RESPONSE_PORT_ID,     // This is the subject-ID..remote_node_id = id,       // Messages cannot be unicast, so use UNSET..transfer_id    = messageTransferId,};