第一次提交

2026-05-29 17:36:34 +08:00
commit 5b3333125d
1318 changed files with 722705 additions and 0 deletions
@@ -0,0 +1,134 @@
+#include "can_comm.h"
+#include "memory.h"
+#include "stdlib.h"
+#include "crc8.h"
+#include "bsp_dwt.h"
+#include "bsp_log.h"
+
+/**
+ * @brief 重置CAN comm的接收状态和buffer
+ *
+ * @param ins 需要重置的实例
+ */
+static void CANCommResetRx(CANCommInstance *ins)
+{
+    // 当前已经收到的buffer清零
+    memset(ins->raw_recvbuf, 0, ins->cur_recv_len);
+    ins->recv_state = 0;   // 接收状态重置
+    ins->cur_recv_len = 0; // 当前已经收到的长度重置
+}
+
+/**
+ * @brief cancomm的接收回调函数
+ *
+ * @param _instance
+ */
+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也等于我们设定接收长度(这是因为暂时不支持动态包长)
+        {
+            comm->recv_state = 1; // 设置接收状态为1,说明已经开始接收
+        }
+        else
+            return; // 直接跳过即可
+    }
+
+    if (comm->recv_state) // 已经收到过帧头
+    {
+        // 如果已经接收到的长度加上当前一包的长度大于总buf len,说明接收错误
+        if (comm->cur_recv_len + _instance->rx_len > comm->recv_buf_len)
+        {
+            CANCommResetRx(comm);
+            return; // 重置状态然后返回
+        }
+
+        // 直接把当前接收到的数据接到buffer后面
+        memcpy(comm->raw_recvbuf + comm->cur_recv_len, _instance->rx_buff, _instance->rx_len);
+        comm->cur_recv_len += _instance->rx_len;
+
+        // 收完这一包以后刚好等于总buf len,说明已经收完了
+        if (comm->cur_recv_len == comm->recv_buf_len)
+        {
+            // 如果buff里本tail的位置等于CAN_COMM_TAIL
+            if (comm->raw_recvbuf[comm->recv_buf_len - 1] == CAN_COMM_TAIL)
+            { // 通过校验,复制数据到unpack_data中
+                if (comm->raw_recvbuf[comm->recv_buf_len - 2] == crc_8(comm->raw_recvbuf + 2, comm->recv_data_len))
+                { // 数据量大的话考虑使用DMA
+                    memcpy(comm->unpacked_recv_data, comm->raw_recvbuf + 2, comm->recv_data_len);
+                    comm->update_flag = 1;           // 数据更新flag置为1
+                    DaemonReload(comm->comm_daemon); // 重载daemon,避免数据更新后一直不被读取而导致数据更新不及时
+                }
+            }
+            CANCommResetRx(comm);
+            return; // 重置状态然后返回
+        }
+    }
+}
+
+static void CANCommLostCallback(void *cancomm)
+{
+    CANCommInstance *comm = (CANCommInstance *)cancomm;
+    CANCommResetRx(comm);
+    LOGWARNING("[can_comm] can comm rx[%d] lost, reset rx state.", &comm->can_ins->rx_id);
+}
+
+CANCommInstance *CANCommInit(CANComm_Init_Config_s *comm_config)
+{
+    CANCommInstance *ins = (CANCommInstance *)malloc(sizeof(CANCommInstance));
+    memset(ins, 0, sizeof(CANCommInstance));
+
+    ins->recv_data_len = comm_config->recv_data_len;
+    ins->recv_buf_len = comm_config->recv_data_len + CAN_COMM_OFFSET_BYTES; // head + datalen + crc8 + tail
+    ins->send_data_len = comm_config->send_data_len;
+    ins->send_buf_len = comm_config->send_data_len + CAN_COMM_OFFSET_BYTES;
+    ins->raw_sendbuf[0] = CAN_COMM_HEADER;            // head,直接设置避免每次发送都要重新赋值,下面的tail同理
+    ins->raw_sendbuf[1] = comm_config->send_data_len; // datalen
+    ins->raw_sendbuf[comm_config->send_data_len + CAN_COMM_OFFSET_BYTES - 1] = CAN_COMM_TAIL;
+    // can instance的设置
+    comm_config->can_config.id = ins; // CANComm的实例指针作为CANInstance的id,回调函数中会用到
+    comm_config->can_config.can_module_callback = CANCommRxCallback;
+    ins->can_ins = CANRegister(&comm_config->can_config);
+
+    Daemon_Init_Config_s daemon_config = {
+        .callback = CANCommLostCallback,
+        .owner_id = (void *)ins,
+        .reload_count = comm_config->daemon_count,
+    };
+    ins->comm_daemon = DaemonRegister(&daemon_config);
+    return ins;
+}
+
+void CANCommSend(CANCommInstance *instance, uint8_t *data)
+{
+    static uint8_t crc8;
+    static uint8_t send_len;
+    // 将data copy到raw_sendbuf中,计算crc8
+    memcpy(instance->raw_sendbuf + 2, data, instance->send_data_len);
+    crc8 = crc_8(data, instance->send_data_len);
+    instance->raw_sendbuf[2 + instance->send_data_len] = crc8;
+
+    // CAN单次发送最大为8字节,如果超过8字节,需要分包发送
+    for (size_t i = 0; i < instance->send_buf_len; i += 8)
+    { // 如果是最后一包,send len将会小于8,要修改CAN的txconf中的DLC位,调用bsp_can提供的接口即可
+        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);
+    }
+}
+
+void *CANCommGet(CANCommInstance *instance)
+{
+    instance->update_flag = 0; // 读取后将更新flag置为0
+    return instance->unpacked_recv_data;
+}
+
+uint8_t CANCommIsOnline(CANCommInstance *instance)
+{
+    return DaemonIsOnline(instance->comm_daemon);
+}
@@ -0,0 +1,92 @@
+/**
+ * @file can_comm.h
+ * @author Neo neozng1@hnu.edu.cn
+ * @brief  用于多机CAN通信的收发模块
+ * @version 0.1
+ * @date 2022-11-27
+ *
+ * @copyright Copyright (c) 2022 HNUYueLu EC all rights reserved
+ *
+ */
+#ifndef CAN_COMM_H
+#define CAN_COMM_H
+
+#include "bsp_can.h"
+#include "daemon.h"
+
+#define MX_CAN_COMM_COUNT 4 // 注意均衡负载,一条总线上不要挂载过多的外设
+
+#define CAN_COMM_MAX_BUFFSIZE 60 // 最大发送/接收字节数,如果不够可以增加此数值
+#define CAN_COMM_HEADER 's'      // 帧头
+#define CAN_COMM_TAIL 'e'        // 帧尾
+#define CAN_COMM_OFFSET_BYTES 4  // 's'+ datalen + 'e' + crc8
+
+#pragma pack(1)
+/* CAN comm 结构体, 拥有CAN comm的app应该包含一个CAN comm指针 */
+typedef struct
+{
+    CANInstance *can_ins;
+    /* 发送部分 */
+    uint8_t send_data_len; // 发送数据长度
+    uint8_t send_buf_len;  // 发送缓冲区长度,为发送数据长度+帧头单包数据长度帧尾以及校验和(4)
+    uint8_t raw_sendbuf[CAN_COMM_MAX_BUFFSIZE + CAN_COMM_OFFSET_BYTES]; // 额外4个bytes保存帧头帧尾和校验和
+    /* 接收部分 */
+    uint8_t recv_data_len; // 接收数据长度
+    uint8_t recv_buf_len;  // 接收缓冲区长度,为接收数据长度+帧头单包数据长度帧尾以及校验和(4)
+    uint8_t raw_recvbuf[CAN_COMM_MAX_BUFFSIZE + CAN_COMM_OFFSET_BYTES]; // 额外4个bytes保存帧头帧尾和校验和
+    uint8_t unpacked_recv_data[CAN_COMM_MAX_BUFFSIZE];                  // 解包后的数据,调用CANCommGet()后cast成对应的类型通过指针读取即可
+    /* 接收和更新标志位*/
+    uint8_t recv_state;   // 接收状态,
+    uint8_t cur_recv_len; // 当前已经接收到的数据长度(包括帧头帧尾datalen和校验和)
+    uint8_t update_flag;  // 数据更新标志位,当接收到新数据时,会将此标志位置1,调用CANCommGet()后会将此标志位置0
+
+    DaemonInstance* comm_daemon;
+} CANCommInstance;
+#pragma pack()
+
+/* CAN comm 初始化结构体 */
+typedef struct
+{
+    CAN_Init_Config_s can_config; // CAN初始化结构体
+    uint8_t send_data_len;        // 发送数据长度
+    uint8_t recv_data_len;        // 接收数据长度
+
+    uint16_t daemon_count; // 守护进程计数,用于初始化守护进程
+} CANComm_Init_Config_s;
+
+/**
+ * @brief 初始化CANComm
+ *
+ * @param config CANComm初始化结构体
+ * @return CANCommInstance*
+ */
+CANCommInstance *CANCommInit(CANComm_Init_Config_s *comm_config);
+
+/**
+ * @brief 通过CANComm发送数据
+ *
+ * @param instance cancomm实例
+ * @param data 注意此地址的有效数据长度需要和初始化时传入的datalen相同
+ */
+void CANCommSend(CANCommInstance *instance, uint8_t *data);
+
+/**
+ * @brief 获取CANComm接收的数据,需要自己使用强制类型转换将返回的void指针转换成指定类型
+ *
+ * @return void* 返回的数据指针
+ * @attention 注意如果希望直接通过转换指针访问数据,如果数据是union或struct,要检查是否使用了pack(n)
+ *            CANComm接收到的数据可以看作是pack(1)之后的,是连续存放的.
+ *            如果使用了pack(n)可能会导致数据错乱,并且无法使用强制类型转换通过memcpy直接访问,转而需要手动解包.
+ *            强烈建议通过CANComm传输的数据使用pack(1)
+ */
+void *CANCommGet(CANCommInstance *instance);
+
+/**
+ * @brief 检查CANComm是否在线
+ * 
+ * @param instance 
+ * @return uint8_t 
+ */
+uint8_t CANCommIsOnline(CANCommInstance *instance);
+
+#endif // !CAN_COMM_H
@@ -0,0 +1,140 @@
+# can_comm
+
+<p align='right'>neozng1@hnu.edu.cn</p>
+
+> TODO:
+>
+> 1. 对`CANCommGet()`进行修改，使得其可以返回数据是否更新的相关信息。
+
+## 重要提醒
+
+如果传输过程中出现多次丢包或长度校验不通过，尤其是传输长度较大的时候，请开启CAN的Auto Retransmission，并尝试修改CANComm实例的发送和接受ID（以提高在总线仲裁中的优先级）。
+
+## 总览和封装说明
+
+CAN comm是用于CAN多机通信的模块。你不需要关心实现的协议，**只需要传入你想发送/接收的结构体的长度**（通过`sizeof()`获取）即可。单帧发送长度目前限制为60字节，如果需要加长可以在`can_comm.h`中修改`CAN_COMM_MAX_BUFFSIZE`的定义值。注意CAN的负载以及使用此模块的发送频率，否则可能造成堵塞。
+
+## 代码结构
+
+.h中放置的是数据定义和外部接口，以及协议的定义和宏，.c中包含一些私有函数。
+
+## 外部接口
+
+```c
+CANCommInstance *CANCommInit(CANComm_Init_Config_s* comm_config);
+void CANCommSend(CANCommInstance *instance, uint8_t *data);
+void *CANCommGet(CANCommInstance *instance);
+uint8_t CANCommIsOnline(CANCommInstance *instance);
+```
+
+第一个函数将会初始化一个CANComm实例，返回其指针。使用CANComm进行通信的应用应该保存返回的指针。初始化需要传入一个初始化结构体。请在应用初始化的时候调用该函数。推荐的结构体配置方式如下：
+
+```c
+/* 初始化结构体的定义 */
+typedef struct
+{
+    can_instance_config_s can_config;
+    uint8_t send_data_len; //发送数据长度
+    uint8_t recv_data_len; //接收数据长度,两者请用sizeof获取
+} CANComm_Init_Config_s;
+
+CANComm_Init_Config_s cconfig = {
+  .can_config = {
+            .can_handle=&hcan1,
+            .tx_id=0x02,
+            .rx_id=0x03},
+  .send_data_len = sizeof(your_data_structure),
+  .recv_data_len = sizeof(recv_data_structure)
+};
+```
+
+第二个函数将会通过CAN发送一帧数据。这里的“帧”不是CAN的一帧报文，而是你使用的数据。在CANComm初始化的时候，使用sizeof获得你要发送的数据的长度。调用此函数时，将你的数据结构或数据cast成`u8`类型的指针传入即可。==**特别注意，你的结构体需要使用预编译指令`#pragma pack(1)`以及`#pragma pack()`包裹**==，从而进行字节压缩而不进行字节对齐，如：
+
+```c
+#pragma pack(1)
+typedef struct
+{
+    uint8_t aa;
+    float bb;
+    double cc;
+    uint16_t dd;
+} some_struct;
+#pragma pack()
+```
+
+只有这样，这个结构体才不会进行padding扩充字节实现字节对齐。你可以尝试一下，如果不使用pack处理，上面的结构体将会占据18个字节以上的空间；开启pack后，会降低至15。更多关于字节对齐的内容，自行查询。
+
+> 后期可能更新字节对齐和内存访问相关的教程。
+
+`CANCommGet()`是获取来自CANComm接收到的数据的接口，返回值为一个void类型指针，你需要通过**强制类型转换**将其变为你设定的接收类型指针，然后就可以访问其数据了。
+
+## 私有函数和变量
+
+```c
+static CANCommInstance *can_comm_instance[MX_CAN_COMM_COUNT] = {NULL};
+static uint8_t idx; 
+static void CANCommResetRx(CANCommInstance *ins);
+static void CANCommRxCallback(can_instance *_instance);
+```
+
+第一个指针数组保存所有的can comm实例，从而在callback中区分不同实例。idx是初始化使用的索引，用于确定每个can comm实例指针存放的位置。
+
+`CANCommResetRx()`在`CANCommRxCallback()`中多次被调用，用于清空接收缓冲区。
+
+`CANCommRxCallback()`是CAN comm初始化can实例时的回调函数，用于can接收中断，进行协议解析。
+
+## 使用范例
+
+例如，这里要发送的数据是一个float，接收的数据是如下的`struct`，**==注意要使用pack==**：
+
+```c
+#pragma pack(1)
+struct test
+{
+ float aa;
+ float bb;
+ float cc;
+ uint16_t dd;
+};
+#pragma pack()
+```
+
+初始化时设置如下：
+
+```c
+CANComm_Init_Config_s cconfig = {
+  .can_config = {
+            .can_handle=&hcan1,
+            .tx_id=0x02,
+            .rx_id=0x03},
+  .send_data_len = sizeof(float),
+  .recv_data_len = sizeof(struct test)
+};
+CANCommInstance* ins = CANCommInit(&cconfig);
+```
+
+通过`CANCommGet()`并使用强制类型转换获得接收到的数据指针：
+
+```c
+struct test* data_ptr=(struct test*)CANCommGet(ins)
+```
+
+发送通过`CANCommSend()`，建议使用强制类型转换：
+
+```c
+float tx=114.514;
+CANCommSend(ins, (uint8_t*)&tx);
+```
+
+## 接收解析流程
+
+CAN comm的通信协议如下：
+
+| 帧头        | 数据长度 | 数据             | crc8校验 | 帧尾        |
+| ----------- | -------- | ---------------- | -------- | ----------- |
+| 's'（0x73） | 0~255    | 最大60（可修改） | 校验码   | 'e'（0x65） |
+| 1-byte      | 1-byte   | n-byte           | 1-byte   | 1-byte      |
+
+接收的流程见代码注释。
+
+流程图如下：![未命名文件](../../.assets/CANcomm.png)