降低message center的冗余度,提升can_comm的接收效率并在发送增加延时保证顺序

modules/can_comm/can_comm.c

@@ -2,6 +2,7 @@
 #include "memory.h"
 #include "stdlib.h"
 #include "crc8.h"
+#include "bsp_dwt.h"
 
 /**
  * @brief 重置CAN comm的接收状态和buffer
@@ -25,7 +26,7 @@ static void CANCommRxCallback(CANInstance *_instance)
 {
     CANCommInstance *comm = (CANCommInstance *)_instance->id; // 注意写法,将can instance的id强制转换为CANCommInstance*类型
 
-    /* 接收状态判断 */
+    /* 当前接收状态判断 */
     if (_instance->rx_buff[0] == CAN_COMM_HEADER && comm->recv_state == 0) // 之前尚未开始接收且此次包里第一个位置是帧头
     {
         if (_instance->rx_buff[1] == comm->recv_data_len) // 如果这一包里的datalen也等于我们设定接收长度(这是因为暂时不支持动态包长)
@@ -51,25 +52,18 @@ static void CANCommRxCallback(CANInstance *_instance)
 
         // 收完这一包以后刚好等于总buf len,说明已经收完了
         if (comm->cur_recv_len == comm->recv_buf_len)
-        {   
+        {
-            // 如果buff里本该是tail的位置不等于CAN_COMM_TAIL
+            // 如果buff里本tail的位置等于CAN_COMM_TAIL
-            if (comm->raw_recvbuf[comm->recv_buf_len - 1] != CAN_COMM_TAIL)
+            if (comm->raw_recvbuf[comm->recv_buf_len - 1] == CAN_COMM_TAIL)
-            {
+            { // 通过校验,复制数据到unpack_data中
-                CANCommResetRx(comm);
+                if (comm->raw_recvbuf[comm->recv_buf_len - 2] == crc_8(comm->raw_recvbuf + 2, comm->recv_data_len))
-                return; // 重置状态然后返回
+                { // 数据量大的话考虑使用DMA
-            }
+                    memcpy(comm->unpacked_recv_data, comm->raw_recvbuf + 2, comm->recv_data_len);
-            else // tail正确, 对数据进行crc8校验
-            {
-                if (comm->raw_recvbuf[comm->recv_buf_len - 2] ==
-                    crc_8(comm->raw_recvbuf + 2, comm->recv_data_len))
-                {   // 通过校验,复制数据到unpack_data中
-                    memcpy(comm->unpacked_recv_data, comm->raw_recvbuf + 2, comm->recv_data_len); // 数据量大的话考虑使用DMA
                     comm->update_flag = 1; // 数据更新flag置为1
                 }
-                CANCommResetRx(comm);
-                return; // 重置状态然后返回
             }
-            return; // 访问完一个can comm直接退出,一次中断只处理一个实例的回调
+            CANCommResetRx(comm);
+            return; // 重置状态然后返回
         }
     }
 }
@@ -108,7 +102,10 @@ void CANCommSend(CANCommInstance *instance, uint8_t *data)
         send_len = instance->send_buf_len - i >= 8 ? 8 : instance->send_buf_len - i;
         CANSetDLC(instance->can_ins, send_len);
         memcpy(instance->can_ins->tx_buff, instance->raw_sendbuf + i, send_len);
-        CANTransmit(instance->can_ins,1);
+        CANTransmit(instance->can_ins, 1);
+        if(instance->send_buf_len - i > 8)
+            DWT_Delay(0.001*0.005); // delay 5ns以保证CAN发送的顺序,如果是最后一包,不需要延时
+        // CAN的邮箱不保证发送顺序,当存在空闲时便放入对应邮箱,因此需要延时保证发送顺序
     }
 }
 

modules/message_center/message_center.c

@@ -1,6 +1,7 @@
 #include "message_center.h"
 #include "stdlib.h"
 #include "string.h"
+#include "bsp_log.h"
 
 /* message_center是fake head node,是方便链表编写的技巧,这样就不需要处理链表头的特殊情况 */
 static Publisher_t message_center = {
@@ -12,6 +13,7 @@ static void CheckName(char *name)
 {
     if (strnlen(name, MAX_EVENT_NAME_LEN + 1) >= MAX_EVENT_NAME_LEN)
     {
+        LOGERROR("EVENT NAME TOO LONG:%s", name);
         while (1)
             ; // 进入这里说明事件名超出长度限制
     }
@@ -21,65 +23,12 @@ static void CheckLen(uint8_t len1, uint8_t len2)
 {
     if (len1 != len2)
     {
+        LOGERROR("EVENT LEN NOT SAME:%d,%d", len1, len2);
         while (1)
             ; // 进入这里说明相同事件的消息长度却不同
     }
 }
 
-Subscriber_t *SubRegister(char *name, uint8_t data_len)
-{
-    CheckName(name);
-    Publisher_t *node = &message_center; // 可以将message_center看作对消息管理器的抽象,它用于管理所有pub和sub
-    while (node->next_event_node)        // 遍历链表,如果当前有发布者已经注册
-    {
-        node = node->next_event_node;            // 指向下一个发布者(发布者发布的事件)
-        if (strcmp(name, node->event_name) == 0) // 如果事件名相同就订阅这个事件
-        {
-            CheckLen(data_len, node->data_len);
-            // 创建新的订阅者结点,申请内存,注意要memset因为新空间不一定是空的,可能有之前留存的垃圾值
-            Subscriber_t *ret = (Subscriber_t *)malloc(sizeof(Subscriber_t));
-            memset(ret, 0, sizeof(Subscriber_t));
-            // 对新建的Subscriber进行初始化
-            ret->data_len = data_len; // 设定数据长度
-            for (size_t i = 0; i < QUEUE_SIZE; ++i)
-            { // 给消息队列的每一个元素分配空间,queue里保存的实际上是数据执指针,这样可以兼容不同的数据长度
-                ret->queue[i] = malloc(sizeof(data_len));
-            }
-            // 如果是第一个订阅者,特殊处理一下
-            if (node->first_subs == NULL)
-            {
-                node->first_subs = ret;
-                return ret;
-            }
-            // 遍历订阅者链表,直到到达尾部
-            Subscriber_t *sub = node->first_subs; // 作为iterator
-            while (sub->next_subs_queue)          // 遍历订阅了该事件的订阅者链表
-            {
-                sub = sub->next_subs_queue; // 移动到下一个订阅者,遇到空指针停下,说明到了链表尾部
-            }
-            sub->next_subs_queue = ret; // 把刚刚创建的订阅者接上
-            return ret;
-        }
-        // 事件名不同,在下一轮循环访问下一个结点
-    }
-    // 遍历完,发现尚未注册事件(还没有发布者);那么创建一个事件,此时node是publisher链表的最后一个结点
-    node->next_event_node = (Publisher_t *)malloc(sizeof(Publisher_t));
-    memset(node->next_event_node, 0, sizeof(Publisher_t));
-    strcpy(node->next_event_node->event_name, name);
-    node->next_event_node->data_len = data_len;
-    // 同之前,创建subscriber作为新事件的第一个订阅者
-    Subscriber_t *ret = (Subscriber_t *)malloc(sizeof(Subscriber_t));
-    memset(ret, 0, sizeof(Subscriber_t));
-    ret->data_len = data_len;
-    for (size_t i = 0; i < QUEUE_SIZE; ++i)
-    { // 给消息队列分配空间
-        ret->queue[i] = malloc(sizeof(data_len));
-    }
-    // 新建的订阅者是该发布者的第一个订阅者,发布者会通过这个指针顺序访问所有订阅者
-    node->next_event_node->first_subs = ret;
-    return ret;
-}
-
 Publisher_t *PubRegister(char *name, uint8_t data_len)
 {
     CheckName(name);
@@ -103,6 +52,34 @@ Publisher_t *PubRegister(char *name, uint8_t data_len)
     return node->next_event_node;
 }
 
+Subscriber_t *SubRegister(char *name, uint8_t data_len)
+{
+    Publisher_t* pub = PubRegister(name, data_len); // 查找或创建该事件的发布者
+    // 创建新的订阅者结点,申请内存,注意要memset因为新空间不一定是空的,可能有之前留存的垃圾值
+    Subscriber_t *ret = (Subscriber_t *)malloc(sizeof(Subscriber_t));
+    memset(ret, 0, sizeof(Subscriber_t));
+    // 对新建的Subscriber进行初始化
+    ret->data_len = data_len; // 设定数据长度
+    for (size_t i = 0; i < QUEUE_SIZE; ++i)
+    { // 给消息队列的每一个元素分配空间,queue里保存的实际上是数据执指针,这样可以兼容不同的数据长度
+        ret->queue[i] = malloc(sizeof(data_len));
+    }
+    // 如果是第一个订阅者,特殊处理一下,将first_subs指针指向新建的订阅者(详见文档)
+    if (pub->first_subs == NULL)
+    {
+        pub->first_subs = ret;
+        return ret;
+    }
+    // 若该话题已经有订阅者, 遍历订阅者链表,直到到达尾部
+    Subscriber_t *sub = pub->first_subs; // 作为iterator
+    while (sub->next_subs_queue)          // 遍历订阅了该事件的订阅者链表
+    {
+        sub = sub->next_subs_queue; // 移动到下一个订阅者,遇到空指针停下,说明到了链表尾部
+    }
+    sub->next_subs_queue = ret; // 把刚刚创建的订阅者接上
+    return ret;
+}
+
 /* 如果队列为空,会返回0;成功获取数据,返回1;后续可以做更多的修改,比如剩余消息数目等 */
 uint8_t SubGetMessage(Subscriber_t *sub, void *data_ptr)
 {

modules/motor/DJImotor/dji_motor.c

@@ -107,6 +107,7 @@ static void MotorSenderGrouping(DJIMotorInstance *motor, CAN_Init_Config_s *conf
         break;
 
     default: // other motors should not be registered here
+        LOGERROR("You must not register other motors using the API of DJI motor.");
         while (1)
             ; // 其他电机不应该在这里注册
     }