1、在windows11上按Win+R调处CMD命令行窗口，然后直接复制下方命令执行：

reg.exe add "HKCU\Software\Classes\CLSID\{86ca1aa0-34aa-4e8b-a509-50c905bae2a2}\InprocServer32" /f

1
2、打开任务管理器，找到Windows资源管理器右击重新启动，右键菜单就会改回老版。

3、如果要恢复右键菜单为win11样式，只要复制输入以下命令，再回车即可。

reg.exe delete "HKCU\Software\Classes\CLSID\{86ca1aa0-34aa-4e8b-a509-50c905bae2a2}" /f

This message is used to verify that this feed (feedId:69567090760705024) belongs to me (userId:69209574504684544). Join me in enjoying the next generation information browser https://follow.is.

背景：使用CCS开发DSP工程时，当随着工程逐渐增大，代码的可读性时逐渐下降的。此时如何能够快速的了解代码工程就显得尤为重要。如果能够解决这个问题，或许也能够约束代码编写时的格式不统一的问题。提升代码的编写质量和可读性。

参考：

1. Eclipse Doxygen Installation also Code Composer Studio v5.x (coder-tronics.com)

2. callgraph工具, 函数调用关系 | cflow, egypt 和 doxygen 使用 - whilewell - 博客园 (cnblogs.com)

3. 相关插件工具：

   1. Doxygen download

   2. Releases · anb0s/eclox (github.com)

   3. Download | Graphviz

实现：

• 首先参考了第一条的安装过程，先下载并安装了doxygen（1.12.0）软件，并且在CCS的市场中安装了插件eclox（0.13.0）

• 然后使用对应插件，并配置对应的doxygen工具的安装目录，使用插件建立得到一份doxygen.file文件

• 编译boxygen文件得到对应的html文件

• 安装Graphviz工具，手动配置对应工具的bin文件夹路径，然后指定生成图片的格式，深度等细节，再次编译doxygen文件。

• 重新查看对应的html文件，可以看到对应的说明文件已经更新了插图。（SVG格式比PNG格式要清晰）

​​

参考

• 能根据代码给出函数调用关系的工具

  • 有一些工具可以分析代码并生成函数调用关系图，帮助你理解代码的结构和函数之间的依赖关系。以下是几种常用的工具：

    1. Doxygen

    • 支持语言：C/C++、Java、Python 等多种语言。

    • 功能：Doxygen 是一个自动生成文档的工具，可以分析代码并生成函数调用关系图。它可以输出多种格式，包括 HTML、LaTeX 和 XML。如果你启用 CALL_GRAPH​ 和 CALLER_GRAPH​ 选项，它还能为每个函数生成调用者和被调用者的图。

    • 使用方法：

      1. 编写配置文件 Doxyfile​。

      2. 在 Doxyfile​ 中启用 CALL_GRAPH = YES​ 和 CALLER_GRAPH = YES​。

      3. 运行 Doxygen，它会生成包含函数调用关系的文档。

    2. Gprof

    • 支持语言：C/C++。

    • 功能：Gprof 是一个性能分析工具，能生成程序的函数调用图。它主要用于检测程序的性能瓶颈，但也能展示函数之间的调用关系。

    • 使用方法：

      1. 编译程序时加上 -pg​ 选项生成可执行文件。

      2. 运行程序，生成 gmon.out​ 文件。

      3. 使用 gprof​ 分析 gmon.out​ 文件，查看函数调用关系。

    3. Cscope

    • 支持语言：C/C++。

    • 功能：Cscope 是一个交互式的代码浏览工具，可以查找函数的定义、调用、全局变量等信息，适合分析大规模的 C/C++ 项目。

    • 使用方法：

      1. 生成索引文件：cscope -R​。

      2. 在 Cscope 的交互界面中查找函数调用关系。

    4. Code2flow

    • 支持语言：Python、JavaScript、Ruby、PHP 等。

    • 功能：Code2flow 是一个简单的工具，可以从代码中生成流程图和调用图，适用于不需要深度分析的小项目。

    • 使用方法：

      1. 安装 code2flow​。

      2. 运行 code2flow your_file.py​，工具会生成相应的调用图。

    5. Callgrind (结合 KCachegrind 使用)

    • 支持语言：C/C++。

    • 功能：Callgrind 是 Valgrind 的一个工具，专门用于分析函数调用关系和性能。生成的报告可以用 KCachegrind 可视化，展示函数调用的详细图谱。

    • 使用方法：

      1. 使用 valgrind --tool=callgrind ./your_program​ 运行程序。

      2. 生成的 callgrind.out​ 文件可以使用 kcachegrind​ 查看调用关系。

    这些工具各有特点，适合不同语言和场景的需求。如果你是在做 C/C++ 项目，可以考虑 Doxygen 和 Gprof。如果是其他语言，Code2flow 和 Cscope 也是不错的选择。你可以根据具体情况选择合适的工具。

• Doxygen生成函数调用图

  • Doxygen 是一个非常强大的文档生成工具，它不仅可以为代码生成文档，还可以生成函数调用图。要生成函数调用图，必须正确配置 Doxygen。以下是如何使用 Doxygen 生成函数调用图的详细步骤：

    1. 安装 Doxygen

    首先，你需要确保 Doxygen 已安装在你的系统中。你可以通过以下方式进行安装：

    • Windows：可以从 Doxygen官网 下载可执行安装文件。

    • Linux：通过包管理器安装，例如：

      sudo apt-get install doxygen graphviz
      

    • macOS：使用 Homebrew 安装：

      brew install doxygen graphviz
      

      Graphviz 是一个用于生成图的工具，Doxygen 生成调用图时依赖于它。因此，你还需要安装 Graphviz。

    2. 配置 Doxygen

    Doxygen 通过配置文件 Doxyfile​ 来控制生成文档的行为。你可以通过以下方式生成该文件：

       doxygen -g
    

    这将创建一个名为 Doxyfile​ 的默认配置文件。

    3. 修改 Doxyfile​ 配置文件

    打开 Doxyfile​，并根据需要修改以下选项以启用函数调用图的生成：

    • 启用调用图和调用者图：

      CALL_GRAPH = YES          # 生成函数的调用图（显示被哪些函数调用）
      CALLER_GRAPH = YES        # 生成函数的调用者图（显示调用了哪些函数）
      

    • 启用图形输出格式：

      HAVE_DOT = YES            # 确保 Graphviz 的 dot 工具可用
      

      如果 HAVE_DOT​ 被设置为 NO​，则需要将其更改为 YES​ 以支持图形生成。

    • 图形显示样式（可选）：

      DOT_IMAGE_FORMAT = svg    # 可以选择生成的图形格式，如 png 或 svg
      

      SVG 格式通常质量更好并支持放大缩小操作。

    • 限制图的深度（可选）：
      如果你的项目很大，可以设置调用图的最大深度以避免生成过于复杂的图：

      MAX_DOT_GRAPH_DEPTH = 2   # 控制生成图的最大深度
      

    4. 生成文档

    配置好 Doxyfile​ 后，在项目根目录下运行以下命令生成文档：

       doxygen Doxyfile
    

    Doxygen 将自动分析你的源代码，并生成包含函数调用图的 HTML 文档。

    5. 查看生成的函数调用图

    在 Doxygen 生成的文档目录中，打开 index.html​ 文件，通过浏览器访问。如果正确配置，点击某个函数时，它的调用图和调用者图将会显示在页面上。

    • 调用图 (Call Graph)：显示当前函数调用了哪些其他函数。

    • 调用者图 (Caller Graph)：显示哪些函数调用了当前函数。

    6. 优化图形显示（可选）

    • 调整图的布局：

      DOT_GRAPH_MAX_NODES = 50  # 控制图形中的最大节点数，防止图形过于复杂
      DOT_TRANSPARENT = YES     # 使图形背景透明（更易嵌入到网页）
      

    • 函数聚类：
      如果你想让相关函数聚集在一起，可以启用函数聚类选项：

      DOT_CLUSTERING = YES
      

    7. 示例调用图

    如果配置成功，生成的调用图可能看起来像这样：

       +--------+    +----------+    +---------+
       | func A | -->| func B    | -->| func C  |
       +--------+    +----------+    +---------+
    

    8. 调试常见问题

    • 调用图未生成：确保 HAVE_DOT​ 设置为 YES​ 并且系统中安装了 Graphviz。

    • 生成的图为空或不完整：检查 MAX_DOT_GRAPH_DEPTH​ 设置，增加图的深度。

    • 图形显示不清晰：尝试将 DOT_IMAGE_FORMAT​ 设置为 svg​ 或其他矢量图格式。

    通过以上步骤，你可以生成函数的调用关系图，帮助你更好地理解项目中的函数调用逻辑。

实例

enum Colors {
    RED = 1,    /**< Represents the color red */
    GREEN = 2,  /**< Represents the color green */
    BLUE = 3    /**< Represents the color blue */
};


/**
 * @brief Adds two integers.
 *
 * @details This function uses simple addition and assumes the input integers are valid.
 * Special care is taken to avoid overflow by ensuring the sum stays within a valid range.
 *
 * @note This function does not check for integer overflow.
 *
 * @param a First integer
 * @param b Second integer
 * @return The sum of a and b
 */
int add1(int a, int b) {
    //! This variable stores the sum of a and b
    int result = 0; /**< The accumulated sum */

    // Add integers with overflow check
    if ((a > 0 && b > 0 && a > INT_MAX - b) || (a < 0 && b < 0 && a < INT_MIN - b)) {
        // Handle overflow case
        return -1; //!< Return error code if overflow occurs
    }

    result = a + b; //!< Perform the addition

    return result; //!< Return the result
}

int add2(int a, int b) {
    int result = 0; /**< The variable that stores the sum of a and b */

    result += a; /**< Add the value of a to the result */
    result += b; /**< Add the value of b to the result */

    return result; /**< Return the calculated sum */
}

/**
 * @brief Adds two integers.
 *
 * This function takes two integers and returns their sum.
 *
 * @param a First integer
 * @param b Second integer
 * @return The sum of a and b
 */
int add3(int a, int b) {
    //! Initialize the result variable to zero.
    int result = 0;

    //! Add the first integer to the result.
    result += a;

    //! Add the second integer to the result.
    result += b;

    //! Return the final result.
    return result;
}


/**
 * @brief Adds two integers.
 *
 * @details
 * This function uses the following local variables:
 * - `result`: Stores the sum of the two input integers.
 *
 * @param a First integer
 * @param b Second integer
 * @return The sum of a and b
 */
int add4(int a, int b) {
    int result = 0; // Local variable to store the sum

    result += a;
    result += b;

    return result;
}


/**
 * @brief Computes the average of an integer array.
 *
 * This function takes an array of integers and its size as input, and returns
 * the average of the array elements. It handles cases where the array is empty.
 *
 * @details
 * The function iterates over the array to compute the sum of its elements.
 * If the array is empty, it returns 0 to avoid division by zero.
 * 
 * Local variables used in this function:
 * - `sum`: Accumulates the sum of array elements.
 * - `i`: Loop counter for iterating through the array.
 *
 * Example usage:
 * @code
 * int arr[] = {1, 2, 3, 4, 5};
 * double avg = compute_average(arr, 5);
 * printf("Average: %f\n", avg);
 * @endcode
 *
 * @param arr The input array of integers.
 * @param size The number of elements in the array.
 * @return The average of the array elements. If the array is empty, returns 0.
 * 
 * @note The return value is of type `double` to allow for decimal averages.
 */
double compute_average(const int* arr, size_t size) {
    //! Sum of the array elements
    int sum = 0;

    //! Loop counter to iterate through the array
    size_t i;

    // If the array is empty, return 0 to avoid division by zero
    if (size == 0) {
        return 0.0;
    }

    // Sum all elements in the array
    for (i = 0; i < size; ++i) {
        sum += arr[i];
    }

    //! Return the computed average as a double
    return (double)sum / size;
}



/**
 * @brief Adds two integers.
 *
 * @details This function uses simple addition and assumes the input integers are valid.
 * Special care is taken to avoid overflow by ensuring the sum stays within a valid range.
 *
 * @note This function does not check for integer overflow.
 *
 * @param a First integer
 * @param b Second integer
 * @return The sum of a and b
 */
int add6(int a, int b) {
    int result = 0; /**< The accumulated sum */

    // Add integers with overflow check
    if ((a > 0 && b > 0 && a > INT_MAX - b) || (a < 0 && b < 0 && a < INT_MIN - b)) {
        // Handle overflow case
        return -1; //!< Return error code if overflow occurs
    }

    result = a + b; //!< Perform the addition

    return result; //!< Return the result
}



int add7(int a, int b) {
    int result = 0; /**< The variable that stores the sum of a and b */

    result += a; /**< Add the value of a to the result */
    result += b; /**< Add the value of b to the result */

    return result; /**< Return the calculated sum */
}


/**
 * @defgroup GeometricShapes Geometric Shape Calculations
 * @brief This module handles the calculations of areas for geometric shapes like circles, squares, and triangles.
 *
 * The functions in this module compute the areas of various geometric shapes by using their respective formulas.
 * @{
 */

/**
 * @brief Initializes the system to compute geometric areas.
 *
 * This function can be used to set up any necessary initial values before computing the areas of shapes.
 */
void init_area_computation(void) {
    shape_count = 0;  // Initialize shape counter
}

/** @} */  // End of GeometricShapes group



/**
 * @brief Computes the area of a circle.
 *
 * This function takes a pointer to a `Circle` structure and calculates its area using the formula:
 * @f$ Area = \pi \times radius^2 @f$.
 * 
 * @f[
 * Area = \pi \times radius^2
 * @f]
 *
 * @param[in] circle A pointer to the `Circle` structure containing the radius.
 * @return The area of the circle.
 */
double compute_circle_area(const Circle* circle) {
    return PI * circle->radius * circle->radius;
}







/**
 * @file example.h
 * @brief This file contains definitions, function prototypes, and data structures
 *        for a simple system that computes geometric shapes' areas.
 * 
 * This file demonstrates how to use Doxygen to document a C header file.
 * It includes macros, structures, function prototypes, and enumeration types.
 * 
 * @author John Doe
 * @date 2024-10-11
 */


/**
 * @def PI
 * @brief The mathematical constant Pi (3.14159...).
 *
 * This macro defines the value of Pi, which is used in geometric calculations.
 */
#define PI 3.141592653589793


/**
 * @enum ShapeType
 * @brief Defines the types of geometric shapes.
 *
 * This enumeration is used to specify the type of shape, 
 * such as a circle, square, or triangle.
 */
typedef enum {
    SHAPE_CIRCLE,   /**< Circle shape */
    SHAPE_SQUARE,   /**< Square shape */
    SHAPE_TRIANGLE  /**< Triangle shape */
} ShapeType;

/**
 * @struct Triangle
 * @brief Represents a triangle with a base and height.
 *
 * This structure stores the base and height of a triangle for area calculations.
 */
typedef struct {
    double base;   /**< The base length of the triangle */
    double height; /**< The height of the triangle */
} Triangle;




/**
 * @struct Circle
 * @brief Represents a circle with a radius.
 *
 * This structure is used to store the radius of a circle for area calculations.
 */
typedef struct {
    double radius; /**< The radius of the circle */
} Circle;

/**
 * @struct Square
 * @brief Represents a square with a side length.
 *
 * This structure stores the side length of a square for area calculations.
 */
typedef struct {
    double side_length; /**< The length of one side of the square */
} Square;



/**
 * @var shape_count
 * @brief Keeps track of the number of shapes processed.
 *
 * This global variable is incremented every time a new shape's area is computed.
 */
int shape_count = 0;


/**
 * @brief Computes the area of a square.
 *
 * This function calculates the area of a square based on its side length.
 *
 * @param[in] square A pointer to the `Square` structure containing the side length.
 * @return The area of the square.
 */
double compute_square_area(const Square* square) {
    return square->side_length * square->side_length;
}

/**
 * @brief Computes the area of a triangle.
 *
 * This function computes the area of a triangle using the formula:
 * @f$ Area = \frac{1}{2} \times base \times height @f$.
 *
 * @param[in] triangle A pointer to the `Triangle` structure containing the base and height.
 * @return The area of the triangle.
 */
double compute_triangle_area(const Triangle* triangle) {
    return 0.5 * triangle->base * triangle->height;
}

在使用 Doxygen 生成文档时，函数内的注释可以通过特定的标记来实现。Doxygen 支持在函数内部添加详细的说明，解释代码逻辑、变量用途或步骤等。这些注释将显示在生成的文档中，帮助开发者理解函数的实现细节。

以下是几种常见的函数内注释方式：

1. 使用 //!​ 或 ///​

可以在函数体内直接使用 //!​ 或 ///​ 注释每个逻辑部分。例如：

好的，下面是一个全面的 C 语言项目注释示例，包含了常见的 Doxygen 注释用法，涵盖文件、函数、变量、结构体、枚举、宏定义、以及组（modules）等内容。这样你可以在实际项目中参考使用，确保所有重要元素都得到充分注释和文档化。

### 文件注释

‍‍```c
/**
 * @file example.h
 * @brief This file contains definitions, function prototypes, and data structures
 *        for a simple system that computes geometric shapes' areas.
 * 
 * This file demonstrates how to use Doxygen to document a C header file.
 * It includes macros, structures, function prototypes, and enumeration types.
 * 
 * @author John Doe
 * @date 2024-10-11
 */

‍

宏定义注释

‍

/**
 * @def PI
 * @brief The mathematical constant Pi (3.14159...).
 *
 * This macro defines the value of Pi, which is used in geometric calculations.
 */
#define PI 3.141592653589793

‍

枚举类型注释

‍

/**
 * @enum ShapeType
 * @brief Defines the types of geometric shapes.
 *
 * This enumeration is used to specify the type of shape, 
 * such as a circle, square, or triangle.
 */
typedef enum {
    SHAPE_CIRCLE,   /**< Circle shape */
    SHAPE_SQUARE,   /**< Square shape */
    SHAPE_TRIANGLE  /**< Triangle shape */
} ShapeType;

‍

结构体注释

‍

/**
 * @struct Circle
 * @brief Represents a circle with a radius.
 *
 * This structure is used to store the radius of a circle for area calculations.
 */
typedef struct {
    double radius; /**< The radius of the circle */
} Circle;

/**
 * @struct Square
 * @brief Represents a square with a side length.
 *
 * This structure stores the side length of a square for area calculations.
 */
typedef struct {
    double side_length; /**< The length of one side of the square */
} Square;

/**
 * @struct Triangle
 * @brief Represents a triangle with a base and height.
 *
 * This structure stores the base and height of a triangle for area calculations.
 */
typedef struct {
    double base;   /**< The base length of the triangle */
    double height; /**< The height of the triangle */
} Triangle;

‍

全局变量注释

‍

/**
 * @var shape_count
 * @brief Keeps track of the number of shapes processed.
 *
 * This global variable is incremented every time a new shape's area is computed.
 */
int shape_count = 0;

‍

函数注释

‍

/**
 * @brief Computes the area of a circle.
 *
 * This function takes a pointer to a `Circle` structure and calculates its area using the formula:
 * @f$ Area = \pi \times radius^2 @f$.
 *
 * @param[in] circle A pointer to the `Circle` structure containing the radius.
 * @return The area of the circle.
 */
double compute_circle_area(const Circle* circle) {
    return PI * circle->radius * circle->radius;
}

/**
 * @brief Computes the area of a square.
 *
 * This function calculates the area of a square based on its side length.
 *
 * @param[in] square A pointer to the `Square` structure containing the side length.
 * @return The area of the square.
 */
double compute_square_area(const Square* square) {
    return square->side_length * square->side_length;
}

/**
 * @brief Computes the area of a triangle.
 *
 * This function computes the area of a triangle using the formula:
 * @f$ Area = \frac{1}{2} \times base \times height @f$.
 *
 * @param[in] triangle A pointer to the `Triangle` structure containing the base and height.
 * @return The area of the triangle.
 */
double compute_triangle_area(const Triangle* triangle) {
    return 0.5 * triangle->base * triangle->height;
}

‍

组（Modules）注释

为了组织代码，你可以使用 Doxygen 的 @defgroup​ 和 @addtogroup​ 标签将相关函数、结构体等归为一组，便于文档阅读。

/**
 * @defgroup GeometricShapes Geometric Shape Calculations
 * @brief This module handles the calculations of areas for geometric shapes like circles, squares, and triangles.
 *
 * The functions in this module compute the areas of various geometric shapes by using their respective formulas.
 * @{
 */

/**
 * @brief Initializes the system to compute geometric areas.
 *
 * This function can be used to set up any necessary initial values before computing the areas of shapes.
 */
void init_area_computation(void) {
    shape_count = 0;  // Initialize shape counter
}

/** @} */  // End of GeometricShapes group

‍

main.c 中的代码示例

为了结合所有的注释，以下是一个主程序文件中使用这些函数的示例。

#include "example.h"

int main(void) {
    Circle circle = {5.0};       // Circle with radius 5.0
    Square square = {4.0};       // Square with side length 4.0
    Triangle triangle = {3.0, 6.0}; // Triangle with base 3.0 and height 6.0

    init_area_computation();

    double circle_area = compute_circle_area(&circle);
    double square_area = compute_square_area(&square);
    double triangle_area = compute_triangle_area(&triangle);

    printf("Circle Area: %f\n", circle_area);
    printf("Square Area: %f\n", square_area);
    printf("Triangle Area: %f\n", triangle_area);

    return 0;
}

‍

其他注释标签

‍

1. @param​ 和 @return​：用于注释函数参数和返回值。

2. @file​：用于文件级别的注释。

3. @struct​ 和 @typedef​：用于结构体和类型定义。

4. @brief​：简要描述。

5. @details​：详细描述。

6. @note​：给出提示或注意事项。

7. @code​ 和 @endcode​：用于嵌入代码示例。

8. @ingroup​：将元素添加到组中。

总结

这是一套完整的 Doxygen 注释示例，展示了如何为 C 语言中常见的元素（如文件、函数、变量、结构体、枚举、宏和组）进行注释。使用这些注释方式，可以确保生成的文档清晰、全面，方便团队协作和代码维护。

### 2. 使用 `/**<` 在变量声明中注释

如果想对函数内部局部变量进行注释的话应该怎么办

最后得到的只是写的注释，并没有给出局部变量的名字

对于函数内的变量，您可以使用 `/**<` 来直接注释变量的声明，帮助读者了解每个变量的作用：

int add(int a, int b) {
int result = 0; /**< The variable that stores the sum of a and b */

result += a; /**< Add the value of a to the result */  
result += b; /**< Add the value of b to the result */

return result; /**< Return the calculated sum */  

}

### 3. 使用 `@details` 和 `@note`

对于较为复杂的函数，可以使用 `@details` 和 `@note` 来解释函数中的特定细节或提醒：

/**

• @brief Adds two integers.

• ‍

• @details This function uses simple addition and assumes the input integers are valid.

• Special care is taken to avoid overflow by ensuring the sum stays within a valid range.

• ‍

• @note This function does not check for integer overflow.

• ‍

• @param a First integer

• @param b Second integer

• @return The sum of a and b
  */
  int add(int a, int b) {
  int result = 0; /**< The accumulated sum */

  // Add integers with overflow check
  if ((a > 0 && b > 0 && a > INT_MAX - b) || (a < 0 && b < 0 && a < INT_MIN - b)) {
  // Handle overflow case
  return -1; //!< Return error code if overflow occurs
  }

  result = a + b; //!< Perform the addition

  return result; //!< Return the result
  }

### 小结

在函数内部添加详细的注释有助于提升代码的可读性和维护性，Doxygen 支持多种注释格式，可以根据项目需求灵活选择。

如果最后生成的文档显示的公式是 `$ Area = \pi \times radius^2 $` 而不是公式的数学格式，可能是 Doxygen 没有正确识别 LaTeX 公式的标记。为了让 Doxygen 正确地显示数学公式，可以尝试以下几种解决方案：

### 1. 确保使用正确的 `@f$` 标签

Doxygen 支持 LaTeX 公式，但它需要你使用正确的标签格式。如果你想让公式显示为数学格式，应该用 `@f$` 来标记公式的开始和结束。例如：

/**

• @brief Computes the area of a circle.

• ‍

• The area of a circle is given by the formula:

• @f$Area = \pi \times radius^2 @f$.

• ‍

• @param[in] radius The radius of the circle.

• @return The area of the circle.
  */
  double compute_circle_area(double radius) {
  return PI * radius * radius;
  }

在生成文档时，Doxygen 会识别 `@f$` 标签并将其转换为 LaTeX 格式，显示为：

[\\text{Area} \= \\pi \\times \\text{radius}\^2]

### 2. 使用 `@f[` 和 `@f]` 包围公式

如果公式较长或你想换行，可以使用 `@f[` 和 `@f]` 标签将整个公式包围起来，生成更加清晰的数学公式表示。例如：

/**

• @brief Computes the area of a circle.

• ‍

• The area of a circle is calculated as:

• @f[

• Area = \pi \times radius^2

• @f]

• ‍

• @param[in] radius The radius of the circle.

• @return The area of the circle.
  */
  double compute_circle_area(double radius) {
  return PI * radius * radius;
  }

这样，公式将会被识别为块状公式，并正确渲染。

### 3. 确保 Doxygen 配置支持 LaTeX

Doxygen 需要特定的配置才能正确处理 LaTeX 公式：

* 打开 `Doxyfile`，确保以下设置启用：
  * `USE_MATHJAX = YES` 让 Doxygen 使用 MathJax 来渲染数学公式。
  * 如果没有 MathJax，你可以设置 `LATEX_OUTPUT = YES`，以确保 LaTeX 能被正确编译成 PDF 或 HTML 格式。

USE_MATHJAX = YES
MATHJAX_FORMAT = HTML

### 4. 确保 MathJax 或 LaTeX 环境可用

* 如果生成 HTML 文档并希望公式正确显示，你需要确保 MathJax 脚本能够正常加载。如果是生成 PDF，你需要 LaTeX 环境来正确编译数学公式。

### 结论

总结来说，确保使用 `@f$` 标签正确标记公式，并且检查 Doxygen 的配置文件是否启用了 MathJax 或 LaTeX 支持。

效果图

​​

‍

magnifyOnFigure是一个工具箱，下载链接为：https://download.csdn.net/download/miao0967020148/15154799?spm=1001.2014.3001.5501

clc;
clear all
close all
disp( sprintf('The figure handle is here passed as an input argument.') ) 
fig = figure;
hold on;
plot(rand(100,1), 'b'); plot(rand(300, 1), 'r'); 
grid on;
hold off;
magnifyOnFigure(fig);
disp('Press a key...')
pause;

​​

 magnifyOnFigure(fig,'displayLinkStyle', 'straight',...
                    'EdgeColor', 'black',...
                    'magnifierShape', 'rectangle',...
                    'initialPositionSecondaryAxes', [80 150 96 56],...
                    'initialPositionMagnifier',     [150 100 24 16],...    
                    'frozenZoomAspectratio', 'on',...
                    'edgeWidth',1); 

'initialPositionSecondaryAxes', [80 150 96 56] 设置放大图的位置

'initialPositionMagnifier', [150 100 24 16]设置放大的区域

先简单了解一下scanf函数：

函数原型：int scanf(const char *format, ...);

参数：要注意的是变量前面的取地址符&不要忘记
返回值 ：返回的是正确按指定格式输入变量的个数，也就是能正确接收到值的变量个数

#include <stdio.h>

int main(int argc, const char **argv)
{
	int a=0,b=0,i=0;
	
	i = scanf("%d %d",&a,&b);
	printf("i = %d\n",i);
	
	return 0;
}

以上代码
如果输入：4 5，则输出结果为：i = 2
如果输入：4 k，则输出结果为：i = 1
因为a和b都是整型数据，输入的k为字符，故正确接收到的变量就只有a，所有才输出 i = 1

回归正题，请看以下代码

#include <stdio.h>

int main(int argc, const char **argv)
{
	char buf[20]={0};
	
	printf("输入一串字符:");
	scanf("%s",buf);
	
	printf("buf = %s\n",buf);	
}

如果输入字符串为：abcd ，返回的结果无疑是：buf = abcd
那如果输入字符串：a b c d 呢，返回的结果则为：buf = a

这是因为：
scanf的读取原理是匹配字符，当scanf从缓冲区读取数据时遇到空格和回车键则会认为读取完毕

因此有以下几种方式解决
（1）使用gets(buf); 替换scanf("%s",buf);即可，但是编译时系统会报警告，说它不安全，因为gets()不能指定获取数据的长度，故可使用fgets()

（2）使用fgets(buf,20,stdin); 替换scanf("%s",buf);即可

函数原型：char *fgets(char *s, int size, FILE *stream);
参数说明：
	char *s	:存储读到的数据的首地址，这里是buf
	int size:存储空间的大小,这里是20
	FILE *stream:读的目标文件的文件流，这里是stdin
返回值：
	成功返回一个指针，指向字符串中第一个字符的地址
	失败/读到末尾，返回NULL

（3）使用scanf("%[^\n]",buf); 替换scanf("%s",buf);即可
这是从一些大牛们的博客找到的方法，一开始并不理解为什么这样就可以，后来找到在这篇博客有说到https://blog.csdn.net/qq_30007603/article/details/81164232

总结为：[^\n]的意思是scanf遇到\n才停止读取，需注意的是,使用
scanf("%[^\n]",buf)后，buf中存放的字符串末尾是没有‘\n’的。

要想知道更多关于scanf的用法和注意事项可以看看：
http://c.biancheng.net/view/160.html

https://www.cnblogs.com/windpiaoxue/p/9184194.html

在DSP的CMD文件中，分配的空间大小计算：如RAMGS2: origin = 0x00E000, length = 0x000E00；他对应的函数意义是，初始地址为0x00E000，大小为0x000E00=14*16*16=3,584，这么大空间。如果长度为0x001000=1*16*16*16=4K。

此外，对于PAGE 0，和PAGE 1中如果有同样名称的变量，不使用的要注释掉，不然CSS Memory allocation的显示会异常，内存不够用报错了，CSS上显示的是使用空间占比为0%

在CMD文件中，PAGE0代表程序空间，PAGE1代表数据空间

PAGE 0 :  /* Program Memory */
          /* Memory (RAM/FLASH) blocks can be moved to PAGE1 for data allocation */
          /* BEGIN is used for the "boot to Flash" bootloader mode   */
    RAMGS2           : origin = 0x00E000, length = 0x000E00           /* reserved for C28 flash to GSRAM*/
    FLASHD           : origin = 0x086000, length = 0x000800	/* on-chip Flash */
PAGE 1 : /* Data Memory */
         /* Memory (RAM/FLASH) blocks can be moved to PAGE0 for program allocation */

在开发DSP时，平时都是在调试程序，是把程序下载到RAM中，而当开发完成后，需要烧写到flash中，但是当程序烧写到flash中后，运行速度要慢，大概降到原来的RAM中的70%~80%。如果对时间敏感的可以复制到RAM中运行，程序如下：

SECTIONS
{
    ramfuncs          : LOAD = FLASHD,

                        RUN = RAMGS2,
                        LOAD_START(_RamfuncsLoadStart),
                        LOAD_SIZE(_RamfuncsLoadSize),
                        LOAD_END(_RamfuncsLoadEnd),
                        RUN_START(_RamfuncsRunStart),
                        RUN_SIZE(_RamfuncsRunSize),
                        RUN_END(_RamfuncsRunEnd),
                        PAGE = 0, ALIGN(4)
}

在其他C文件中，定义函数时，能够声明该函数运行的位置

#pragma CODE_SECTION(DABCtrlFun_PI, "ramfuncs");
void DABCtrlFun_PI(DAB_PI_CTRL_COEFFS *coeffs,DAB_PI_CTRL_VARS *vars)
{
    vars->Err = vars->Ref - vars->Fdb;
    vars->Out0 = vars->Out1 + vars->Err * coeffs->Ki * vars->AntiSat;
    vars->Out1 = vars->Out0;
    vars->Out0 = vars->Out0 + vars->Err * coeffs->Kp;
    if(vars->Out0 > coeffs->OutMax)
    {
        vars->Out0 = coeffs->OutMax;
        if(vars->Err > 0)
        {
            vars->AntiSat = 0;
        }
        else
        {
            vars->AntiSat = 1;
        }
    }
    else if(vars->Out0 <= coeffs->OutMin)  //todo
    {
        vars->Out0 = coeffs->OutMin;
        if(vars->Err < 0)
        {
            vars->AntiSat = 0;
        }
        else
        {
            vars->AntiSat = 1;
        }
    }
    else
    {
        vars->AntiSat = 1;
    }
}

在工程实际中，应用最为广泛的调节器控制规律为比例、积分、微分控制，简称PID控制，又称PID调节。

PID控制原理

在模拟控制系统中，控制器最常用的控制规律是PID控制。模拟PID控制系统原理框图如图7-1所示。系统由模拟PID控制器和被控对象组成。

PID控制器是一种线性控制器，它根据给定值y_d\left(t\right)与实际输出值y\left(t\right)构成控制偏差：

PID的控制规律为：

或可以写成传递函数的形式，

式中，k_p为比例系数，T_1积分时间常数，T_D为微分时间常数。

基于PID的控制仿真

程序进行仿真

根据PID控制算法，对下列对象进行控制：

PID控制参数为：k_p = 8, k_i = 0.10, k_d = 10

MATLAB程序如下：

%%
%增量式PID Increment PID Controller
clc% 清屏
clear all;%删除workplace变量
close all;%关掉显示图形窗口

ts=0.001; % 采样时间
sys=tf(400,[1,50,0]); % 传递函数
dsys=c2d(sys,ts,'z');% 连续模型离散化
[num,den]=tfdata(dsys,'v');% 获得分子分母
%PID控制量
u_1=0.0;u_2=0.0;u_3=0.0;
y_1=0;y_2=0;y_3=0;

x=[0,0,0]';
% 误差
error_1=0;
error_2=0;
for k=1:1:1000
    time(k)=k*ts;
    yd(k)=1.0;
    % PID参数
    kp=8; %比例系数
    ki=0.10;%积分系数
    kd=10;%微分系数

    du(k)=kp*x(1)+kd*x(2)+ki*x(3); 
    u(k)=u_1+du(k);

    if u(k)>=10
      u(k)=10;
    end
    if u(k)<=-10
      u(k)=-10;
    end   
    y(k)=-den(2)*y_1-den(3)*y_2+num(2)*u_1+num(3)*u_2;

    error=yd(k)-y(k);
    u_3=u_2;u_2=u_1;u_1=u(k);
    y_3=y_2;y_2=y_1;y_1=y(k);
    x(1)=error-error_1;             %Calculating P
    x(2)=error-2*error_1+error_2;   %Calculating D
    x(3)=error;                     %Calculating I

    error_2=error_1;
    error_1=error;
end
figure(1);
plot(time,yd,'r',time,y,'b','linewidth',2);
xlabel('time(s)');ylabel('yd,y');
grid on
title('增量式PID跟踪响应曲线')
legend('Ideal position signal','Position tracking');
figure(2);
plot(time,yd-y,'r','linewidth',2);
xlabel('time(s)');ylabel('error');
grid on
title('增量式PID跟踪误差');

使用Simulink进行仿真

采用MATLAB/Simulink中PID控制器进行模型控制，搭建相应的PID控制仿真文件如图7-4所示:

PID控制器参数设置如图7-5所示:

PID控制参数为：k_p = 8, k_i = 0.10, k_d = 10,对其进行仿真输出图形如图所示:

自己搭建PID控制器进行仿真

对应的控制输出如图所示：

基于S函数的PID控制系统仿真

考虑一电动机被控对象传递函数：

采用MATLAB脚本文件，利用ode45的方法求解该连续对象方程，输入指令方程为一正弦函数：

采用PID控制方法设计控制器，其中采用PID参数为：k_p = 20, k_d = 0.5

编写MATLAB PID控制程序如下：

clear all;
close all;
 
ts=0.001;  %Sampling time
xk=zeros(2,1);
e_1=0;
u_1=0;
 
for k=1:1:2000
time(k) = k*ts;
 
yd(k)=0.50*sin(1*2*pi*k*ts);
  
para=u_1;
tSpan=[0 ts];
[tt,xx]=ode45('ysw13_3plant',tSpan,xk,[],para);
xk = xx(length(xx),:);
y(k)=xk(1); 
e(k)=yd(k)-y(k);
de(k)=(e(k)-e_1)/ts; 
 
u(k)=20.0*e(k)+0.50*de(k);
%Control limit
if u(k)>10.0
   u(k)=10.0;
end
if u(k)<-10.0
   u(k)=-10.0;
end
 
u_1=u(k);
e_1=e(k);
end
figure(1);
plot(time,yd,'r',time,y,'k:','linewidth',2);
xlabel('time(s)');ylabel('yd,y');
legend('实际信号','仿真结果'); 
figure(2);
plot(time,yd-y,'r','linewidth',2);
xlabel('time(s)'),ylabel('误差');
title('误差')

function dy = PlantModel(t,y,flag,para)
u=para;
J=0.0067;B=0.1;
 
dy=zeros(2,1);
dy(1) = y(2);
dy(2) = -(B/J)*y(2) + (1/J)*u;
end

考虑被控对象为三阶传递函数

采用Simulink模块与Interpreted MATLAB Fcn函数相结合的形式，利用ode45的方法求解。

输入指令方程为一正弦函数

采用PID控制方法设计控制器，其中采用PID参数为:k_p = 2.5, k_i = 0.02, k_d = 0.5,搭建PID控制仿真模型，如图所示：

其中控制器程序如下：

function [u]=pidsimf(u1,u2)
persistent pidmat errori error_1
t=u1;
if t==0
   errori=0;
   error_1=0;
end   
 
kp=2.5;
ki=0.020;
kd=0.50;
 
error=u2;
errord=error-error_1;
errori=errori+error;
 
u=kp*error+kd*errord+ki*errori;
error_1=error;
end

​ 运行仿真程序，仿真数据自动保存到工作区中，采用如下画图程序进行数据显示。

close all;
figure(1);
plot(t,y(:,1),'r',t,y(:,2),'k:','linewidth',2);
xlabel('time(s)');ylabel('yd,y');
legend('实际信号','仿真结果');
figure(2);
plot(t,y(:,1)-y(:,2),'r','linewidth',2);
xlabel('time(s)'),ylabel('误差');
title('误差')

​ 运行画图程序输出图形如图所示。

采用Simulink模块与S函数的方法进行对象建模求解

输入指令方程为一正弦函数

采用PID控制方法设计控制器，其中采用PID参数为:k_p = 1.5, k_i = 2.0, k_d = 0.05,搭建PID控制仿真模型，如图所示：

function [sys,x0,str,ts]=exp_pidf(t,x,u,flag)
switch flag,
case 0           % initializations
    [sys,x0,str,ts] = mdlInitializeSizes;
case 2           % discrete states updates
    sys = mdlUpdates(x,u);
case 3           % computation of control signal
%    sys = mdlOutputs(t,x,u,kp,ki,kd,MTab);
    sys=mdlOutputs(t,x,u);
case {1, 4, 9}   % unused flag values
    sys = [];
otherwise        % error handling
    error(['Unhandled flag = ',num2str(flag)]);
end;

%==============================================================
% when flag=0, perform system initialization
%==============================================================
function [sys,x0,str,ts] = mdlInitializeSizes
sizes = simsizes;        % read default control variables
sizes.NumContStates = 0; % no continuous states
sizes.NumDiscStates = 3; % 3 states and assume they are the P/I/D components
sizes.NumOutputs = 1;    % 2 output variables: control u(t) and state x(3)
sizes.NumInputs = 2;     % 4 input signals
sizes.DirFeedthrough = 1;% input reflected directly in output
sizes.NumSampleTimes = 1;% single sampling period
sys = simsizes(sizes);   % 
x0 = [0; 0; 0];          % zero initial states
str = []; 
ts = [-1 0];             % sampling period
%==============================================================
% when flag=2, updates the discrete states
%==============================================================
function sys = mdlUpdates(x,u)
T=0.001;
sys=[ u(1); 
      x(2)+u(1)*T;
      (u(1)-u(2))/T];

%==============================================================
% when flag=3, computates the output signals
%==============================================================
function sys = mdlOutputs(t,x,u,kp,ki,kd,MTab)

kp=1.5;
ki=2.0;
kd=0.05;

%sys=[kp,ki,kd]*x;
sys=kp*x(1)+ki*x(2)+kd*x(3);

运行仿真程序，仿真数据自动保存到工作区中，采用如下画图程序进行数据显示。

close all;
figure(1);
plot(t,y(:,1),'r',t,y(:,2),'k:','linewidth',2);
xlabel('time(s)');ylabel('yd,y');
legend('实际信号','仿真结果');
figure(2);
plot(t,y(:,1)-y(:,2),'r','linewidth',2);
xlabel('time(s)'),ylabel('误差');
title('误差')

基于PID的倒立摆小车控制仿真

暂时省略，参考意义不大：

直线式倒立摆中，小车只有水平方向的直线运动，模型的非线性因素比较少，有利于倒立摆的控制；而在直线式倒立摆中，旋臂处在绕轴转动的状态，同时具有水平和垂直两个方向的运动，模型中非线性因素较多，对倒立摆的控制算法较高。