A modular control algorithms library implemented in C, featuring power control, FOC (Field-Oriented Control), and various control algorithms for embedded systems.

一个模块化的C语言控制算法库，包含电源控制、FOC（磁场定向控制）等多种嵌入式系统控制算法。

• Modular Architecture (模块化架构): Each algorithm is an independent module
• High Performance (高性能): Assembly-optimized versions for critical algorithms (ARM Cortex-M)
• Portable (可移植): Supports multiple processor architectures and compilers
• Well-Tested (完善测试): Comprehensive unit tests with 85%+ pass rate
• Easy to Use (易于使用): Unified API interfaces and clear documentation

Windows (PowerShell):

.\run_all_tests.ps1

Linux/macOS (Bash):

chmod +x run_all_tests.sh
./run_all_tests.sh

Windows:

.\run_all_tests.ps1 -Coverage

Linux/macOS:

./run_all_tests.sh --coverage

For detailed testing instructions, see TESTING.md.

PID Controllers (PID控制器族)

• Position PID (位置式PID)
• Incremental PID (增量式PID)
• Integral Separation PID (积分分离PID)
• Anti-Windup PID (抗积分饱和PID)

Advanced Control (先进控制)

• Fuzzy PID (模糊PID)
• Sliding Mode Control (滑模控制)
• Model Predictive Control (模型预测控制)
• Neural Network PID (神经网络PID)
• Genetic Algorithm (遗传算法优化)

FOC Core Algorithms (FOC核心算法)

• Clarke Transform (Clarke变换)
• Park Transform (Park变换)
• Current Loop Control (电流环控制)
• Speed Loop Control (速度环控制)
• Position Loop Control (位置环控制)

PWM Modulation (PWM调制)

• SVPWM (空间矢量PWM)
• SPWM (正弦PWM)
• DPWM (不连续PWM)
• Deadtime Compensation (死区补偿)

Sensorless Control (无感控制)

• I/F Startup (I/F启动)
• High Frequency Injection (高频注入法)
• Hybrid Sensorless (混合无感控制)

Field Weakening (弱磁控制)

• Voltage Limit Weakening (电压限幅弱磁)
• MTPA Control (最大转矩电流比)

Parameter Identification (参数辨识)

• Resistance Identification (电阻辨识)
• Inductance Identification (电感辨识)
• Recursive Least Squares (递推最小二乘法)

DC-DC Converters (DC-DC变换器)

• Buck Converter (Buck变换器)
• Boost Converter (Boost变换器)
• Buck-Boost Converter (Buck-Boost变换器)
• Full Bridge Converter (全桥变换器)
• Half Bridge Converter (半桥变换器)
• LLC Resonant Converter (LLC谐振变换器)

Protection & Soft Start (保护与软启动)

• Soft Start Algorithm (软启动算法)
• Overcurrent Protection (过流保护)

Low-Pass Filters (低通滤波器)

• First Order LPF (一阶低通)
• Second Order LPF (二阶低通)
• Butterworth Filter (巴特沃斯滤波器)

Average Filters (平均滤波器)

• Moving Average (移动平均)
• Median Filter (中值滤波)

Advanced Filters (高级滤波器)

• Kalman Filter (卡尔曼滤波器)
• IIR Filter (IIR滤波器)
• FIR Filter (FIR滤波器)

• Sliding Mode Observer (滑模观测器)
• Extended Kalman Filter (扩展卡尔曼滤波器)
• Luenberger Observer (龙伯格观测器)

Basic Math (基本数学函数)

• CORDIC Algorithm (CORDIC算法)
• Lookup Table Trigonometry (查表法三角函数)
• Saturation & Limiting (饱和与限幅)

Matrix Operations (矩阵运算)

• Matrix Add/Subtract/Multiply (矩阵加减乘)
• Matrix Inverse (矩阵求逆)
• Matrix Decomposition (矩阵分解: LU, QR, Cholesky)

Optimization (优化算法)

• Gradient Descent (梯度下降)
• Newton Method (牛顿法)
• Particle Swarm Optimization (粒子群优化)

Interpolation & Fitting (插值与拟合)

• Linear Interpolation (线性插值)
• Cubic Spline (三次样条插值)
• Least Squares Fitting (最小二乘拟合)

• FFT/IFFT (快速傅里叶变换)
• Window Functions (窗函数: Hanning, Hamming, Blackman)

control-algorithms-library/
├── include/              # Public header files (公共头文件)
│   ├── cal_types.h      # Data type definitions (数据类型定义)
│   ├── cal_math.h       # Math function interfaces (数学函数接口)
│   ├── cal_error.h      # Error code definitions (错误码定义)
│   └── cal_config.h     # Configuration options (配置选项)
├── src/                 # Algorithm implementations (算法实现)
│   ├── control/         # Control algorithms (控制算法)
│   ├── motor/           # Motor control algorithms (电机控制)
│   ├── power/           # Power control algorithms (电源控制)
│   ├── filter/          # Filter algorithms (滤波算法)
│   ├── observer/        # Observer algorithms (观测器)
│   ├── math/            # Math library (数学库)
│   └── signal/          # Signal processing (信号处理)
├── asm/                 # Assembly optimizations (汇编优化)
│   └── arm_cortex_m/    # ARM Cortex-M optimizations
├── tests/               # Unit tests (单元测试)
├── benchmarks/          # Performance benchmarks (性能基准测试)
├── examples/            # Usage examples (使用示例)
└── docs/                # Documentation (文档)

• CMake 3.10 or higher
• C99-compatible compiler (GCC, Clang, MSVC)
• Make or Ninja build system
• (Optional) ARM toolchain for assembly optimizations

Basic Build (基本编译)

# Create build directory
mkdir build
cd build

# Configure
cmake ..

# Build
cmake --build .

# Run tests
ctest

Build with Options (带选项编译)

# Enable double precision and assembly optimization
cmake -DCAL_USE_DOUBLE_PRECISION=ON -DCAL_USE_ASM_OPTIMIZATION=ON ..
cmake --build .

# Build in Release mode for better performance
cmake -DCMAKE_BUILD_TYPE=Release ..
cmake --build .

# Build without tests (faster)
cmake -DCAL_BUILD_TESTS=OFF ..
cmake --build .

# For ARM Cortex-M (bare metal)
cmake -DCMAKE_TOOLCHAIN_FILE=arm-none-eabi.cmake \
      -DCAL_USE_ASM_OPTIMIZATION=ON ..
cmake --build .

# For ARM Cortex-A (Linux)
cmake -DCMAKE_TOOLCHAIN_FILE=arm-linux-gnueabihf.cmake ..
cmake --build .

#include "cal_types.h"
#include "cal_error.h"
#include "cal_math.h"
#include "cal_pid.h"

int main(void) {
    // Initialize PID controller
    cal_pid_config_t pid_config = {
        .kp = 1.0f,
        .ki = 0.1f,
        .kd = 0.01f,
        .integral_max = 100.0f,
        .integral_min = -100.0f,
        .output_max = 100.0f,
        .output_min = -100.0f
    };
    
    cal_pid_t pid;
    cal_error_t err = cal_pid_init(&pid, &pid_config);
    if (err != CAL_OK) {
        // Handle error
        return -1;
    }
    
    // Execute PID control
    cal_real_t setpoint = 100.0f;
    cal_real_t feedback = 80.0f;
    cal_real_t output;
    
    err = cal_pid_execute(&pid, setpoint, feedback, 0.01f, &output);
    if (err != CAL_OK) {
        // Handle error
        return -1;
    }
    
    // Use saturate function
    cal_real_t value = cal_saturate(15.0, 0.0, 10.0);
    // value = 10.0
    
    return 0;
}

#include "cal_clarke.h"
#include "cal_park.h"
#include "cal_svpwm.h"
#include "cal_current_loop.h"

// Measure three-phase currents
cal_abc_t i_abc = {10.0f, -5.0f, -5.0f};

// Clarke transform (abc → αβ)
cal_alphabeta_t i_alphabeta;
clarke_transform(&i_abc, &i_alphabeta);

// Park transform (αβ → dq)
cal_dq_t i_dq;
cal_real_t theta = 1.57f;  // 90 degrees
park_transform(&i_alphabeta, theta, &i_dq);

// Current loop control
cal_current_loop_t current_loop;
// ... initialize current_loop ...

cal_real_t vd, vq;
cal_current_loop_execute(&current_loop, 
                        0.0f,      // id_ref
                        5.0f,      // iq_ref
                        i_dq.d,    // id_feedback
                        i_dq.q,    // iq_feedback
                        100.0f,    // omega_e
                        &vd, &vq);

// Inverse Park transform (dq → αβ)
cal_dq_t v_dq = {vd, vq};
cal_alphabeta_t v_alphabeta;
inverse_park_transform(&v_dq, theta, &v_alphabeta);

// SVPWM modulation (αβ → duty cycles)
cal_svpwm_t svpwm;
// ... initialize svpwm ...

cal_abc_t duty_abc;
cal_svpwm_execute(&svpwm, v_alphabeta.alpha, v_alphabeta.beta, &duty_abc);

#include "cal_buck.h"
#include "cal_soft_start.h"

// Initialize Buck converter controller
cal_buck_voltage_mode_config_t buck_config = {
    .vref = 12.0f,           // Target voltage: 12V
    .vin = 24.0f,            // Input voltage: 24V
    .pid_config = {
        .kp = 0.5f,
        .ki = 100.0f,
        .kd = 0.0f,
        .output_max = 0.95f,  // Max duty cycle
        .output_min = 0.05f   // Min duty cycle
    }
};

cal_buck_voltage_mode_t buck;
cal_buck_voltage_mode_init(&buck, &buck_config);

// Initialize soft start
cal_soft_start_config_t ss_config = {
    .target_value = 12.0f,
    .startup_time = 0.5f,    // 500ms soft start
    .sample_time = 0.0001f   // 100us sample time
};

cal_soft_start_t soft_start;
cal_soft_start_init(&soft_start, &ss_config);
cal_soft_start_begin(&soft_start);

// Control loop
while (!cal_soft_start_is_completed(&soft_start)) {
    // Get soft start reference
    cal_real_t vref_ss = cal_soft_start_get_output(&soft_start);
    
    // Measure output voltage
    cal_real_t vout = measure_voltage();
    
    // Execute Buck controller
    cal_real_t duty;
    cal_buck_voltage_mode_execute(&buck, vref_ss, vout, &duty);
    
    // Apply PWM duty cycle
    set_pwm_duty(duty);
    
    // Update soft start
    cal_soft_start_update(&soft_start);
}

#include "cal_moving_average.h"
#include "cal_kalman.h"

// Moving average filter
cal_moving_average_config_t ma_config = {
    .window_size = 10
};

cal_moving_average_t ma_filter;
cal_moving_average_init(&ma_filter, &ma_config);

// Filter noisy signal
cal_real_t noisy_signal = 100.5f;
cal_real_t filtered;
cal_moving_average_execute(&ma_filter, noisy_signal, &filtered);

// Kalman filter for sensor fusion
cal_kalman_config_t kf_config = {
    .process_noise = 0.01f,
    .measurement_noise = 0.1f,
    .initial_estimate = 0.0f,
    .initial_error = 1.0f
};

cal_kalman_t kalman;
cal_kalman_init(&kalman, &kf_config);

cal_real_t measurement = 25.3f;
cal_real_t estimate;
cal_kalman_update(&kalman, measurement, &estimate);

See the examples/ directory for complete, runnable examples:

• example_foc_complete.c - Complete FOC motor control system (完整FOC控制系统)
• example_power_control_complete.c - Complete power supply control (完整电源控制)
• example_soft_start_protection.c - Soft start with protection (软启动与保护)
• example_neural_pid.c - Neural network PID controller (神经网络PID)
• example_genetic_algorithm.c - Genetic algorithm optimization (遗传算法优化)

Using GCC:

gcc your_program.c -o your_program -lcal -lm

Using CMake:

target_link_libraries(your_program cal m)

For embedded systems (bare metal):

arm-none-eabi-gcc your_program.c -o your_program.elf \
    -I/path/to/cal/include \
    -L/path/to/cal/lib \
    -lcal -lm

Edit include/cal_config.h to configure the library behavior:

/* Uncomment to use double precision (默认使用单精度float) */
/* #define CAL_USE_DOUBLE_PRECISION */

• Single Precision (float): Default, faster on most embedded systems
• Double Precision (double): Higher accuracy, slower on systems without hardware double support

/* Uncomment to enable assembly optimization */
/* #define CAL_USE_ASM_OPTIMIZATION */

When enabled, the library automatically detects the target architecture:

• ARM Cortex-M: Uses FPU instructions for Clarke/Park transforms, SVPWM, trigonometry
• ARM Cortex-A: Uses NEON SIMD instructions (future support)
• RISC-V: Uses RV32F/RV64D instructions (future support)

Performance Improvement:

• Clarke Transform: ~2-3x faster
• Park Transform: ~2-3x faster
• SVPWM: ~1.5-2x faster
• Trigonometric functions: ~3-5x faster

Pre-defined constants for common calculations:

CAL_PI          // π = 3.14159265358979323846
CAL_2PI         // 2π = 6.28318530717958647692
CAL_PI_2        // π/2 = 1.57079632679489661923
CAL_PI_4        // π/4 = 0.78539816339744830962
CAL_SQRT3       // √3 = 1.73205080756887729352
CAL_SQRT3_2     // √3/2 = 0.86602540378443864676
CAL_1_SQRT3     // 1/√3 = 0.57735026918962576450
CAL_2_SQRT3     // 2/√3 = 1.15470053837925152901
CAL_SQRT2       // √2 = 1.41421356237309504880
CAL_1_SQRT2     // 1/√2 = 0.70710678118654752440

#define CAL_SIN_TABLE_SIZE  1024  // Sine lookup table size

Larger table = higher accuracy but more memory usage:

• 256 entries: ~1KB, accuracy ~0.1%
• 1024 entries: ~4KB, accuracy ~0.01%
• 4096 entries: ~16KB, accuracy ~0.001%

#define CAL_MAX_MATRIX_SIZE  16   // Maximum matrix dimension

Limits the maximum size of matrices for stack allocation. Increase if you need larger matrices.

#define CAL_MAX_FILTER_ORDER  8   // Maximum filter order

Maximum order for IIR/FIR filters. Higher order = better filtering but more computation.

// For single precision (float)
#define CAL_EPSILON     1e-6f   // Small value threshold
#define CAL_REAL_MAX    1e38f   // Maximum value

// For double precision (double)
#define CAL_EPSILON     1e-10   // Small value threshold
#define CAL_REAL_MAX    1e308   // Maximum value

Used for:

• Division by zero protection
• Floating point comparison
• Numerical stability checks

CAL_ABS(x)      // Absolute value (fabsf or fabs)
CAL_SQRT(x)     // Square root (sqrtf or sqrt)

Automatically selects the correct function based on precision setting.

High Performance Embedded System (高性能嵌入式):

// Single precision + Assembly optimization
#define CAL_USE_ASM_OPTIMIZATION
#define CAL_SIN_TABLE_SIZE  1024

High Accuracy Desktop Application (高精度桌面应用):

// Double precision + Large lookup tables
#define CAL_USE_DOUBLE_PRECISION
#define CAL_SIN_TABLE_SIZE  4096
#define CAL_MAX_MATRIX_SIZE  32

Memory Constrained System (内存受限系统):

// Single precision + Small tables
#define CAL_SIN_TABLE_SIZE  256
#define CAL_MAX_MATRIX_SIZE  8
#define CAL_MAX_FILTER_ORDER  4

The library uses Unity test framework for unit testing.

Run all tests:

cd build
ctest

# Or with verbose output
ctest -V

# Run tests in parallel
ctest -j4

Run specific test:

# Run individual test executables
./tests/test_math
./tests/test_clarke
./tests/test_pid
./tests/test_svpwm

Generate test coverage report (requires gcov/lcov):

# Configure with coverage flags
cmake -DCMAKE_BUILD_TYPE=Debug -DCAL_ENABLE_COVERAGE=ON ..
cmake --build .

# Run tests
ctest

# Generate coverage report
lcov --capture --directory . --output-file coverage.info
lcov --remove coverage.info '/usr/*' --output-file coverage.info
lcov --list coverage.info

# Generate HTML report
genhtml coverage.info --output-directory coverage_html

tests/
├── unit/                    # Unit tests (单元测试)
│   ├── test_clarke.c       # Clarke transform tests
│   ├── test_park.c         # Park transform tests
│   ├── test_pid.c          # PID controller tests
│   ├── test_svpwm.c        # SVPWM tests
│   ├── test_filters.c      # Filter tests
│   └── ...
├── unity/                   # Unity test framework
└── test_utils.c/h          # Test utility functions

Example unit test:

#include "unity.h"
#include "cal_clarke.h"

void setUp(void) {
    // Setup before each test
}

void tearDown(void) {
    // Cleanup after each test
}

void test_clarke_transform_balanced(void) {
    cal_abc_t abc = {1.0f, -0.5f, -0.5f};
    cal_alphabeta_t alphabeta;
    
    cal_error_t result = clarke_transform(&abc, &alphabeta);
    
    TEST_ASSERT_EQUAL(CAL_OK, result);
    TEST_ASSERT_FLOAT_WITHIN(0.001f, 1.0f, alphabeta.alpha);
    TEST_ASSERT_FLOAT_WITHIN(0.001f, 0.0f, alphabeta.beta);
}

int main(void) {
    UNITY_BEGIN();
    RUN_TEST(test_clarke_transform_balanced);
    return UNITY_END();
}

API documentation is generated using Doxygen:

# Generate documentation
doxygen Doxyfile

# Documentation will be in docs/html/index.html

Or use the provided scripts:

# Linux/Mac
./generate_docs.sh

# Windows
.\generate_docs.ps1

See docs/QUICK_REFERENCE.md for a quick API reference guide.

• docs/API_SUMMARY.md - API summary and usage patterns
• docs/CLARKE_ASM_OPTIMIZATION.md - Clarke transform assembly optimization details
• docs/SVPWM_ASM_OPTIMIZATION.md - SVPWM assembly optimization details
• docs/TRIG_ASM_OPTIMIZATION.md - Trigonometric function optimization details
• Implementation guides for specific algorithms in docs/ directory

cd build

# Run all benchmarks
./benchmarks/benchmark_all

# Run specific benchmarks
./benchmarks/benchmark_clarke
./benchmarks/benchmark_park
./benchmarks/benchmark_svpwm
./benchmarks/benchmark_matrix
./benchmarks/benchmark_fft

Typical performance on ARM Cortex-M4 @ 168MHz (single precision):

Note: Actual performance depends on compiler optimization level, target hardware, and data cache configuration.

#include "benchmark_utils.h"
#include "cal_clarke.h"

void benchmark_clarke_transform(void) {
    const int iterations = 10000;
    cal_abc_t abc = {1.0f, -0.5f, -0.5f};
    cal_alphabeta_t alphabeta;
    
    uint64_t start = get_cycle_count();
    
    for (int i = 0; i < iterations; i++) {
        clarke_transform(&abc, &alphabeta);
    }
    
    uint64_t end = get_cycle_count();
    uint64_t cycles = (end - start) / iterations;
    
    printf("Clarke transform: %llu cycles per call\n", cycles);
}

1. Compilation Errors (编译错误)

Problem: undefined reference to 'sinf' or math functions

Solution: Link with math library (-lm)
gcc your_program.c -o your_program -lcal -lm

Problem: CAL_USE_ASM_OPTIMIZATION defined but assembly code not compiling

Solution: Ensure you're using ARM toolchain and target is ARM Cortex-M
cmake -DCMAKE_TOOLCHAIN_FILE=arm-none-eabi.cmake ..

2. Runtime Errors (运行时错误)

Problem: PID controller output saturates immediately

Solution: Check output limits and integral limits in config
- Ensure output_max/min are reasonable for your application
- Verify integral_max/min prevent windup
- Check Kp, Ki, Kd gains are properly tuned

Problem: Clarke/Park transform results are incorrect

Solution: Verify input data
- Ensure three-phase currents sum to zero (Ia + Ib + Ic ≈ 0)
- Check angle θ is in radians, not degrees
- Verify floating point precision matches your data type

Problem: SVPWM generates invalid duty cycles (>1.0 or <0.0)

Solution: Check voltage limits
- Ensure Vdc (DC bus voltage) is set correctly
- Verify input voltage magnitude doesn't exceed Vdc/√3
- Enable overmodulation handling if needed

3. Performance Issues (性能问题)

Problem: Algorithms running slower than expected

Solution: Enable optimizations
- Use Release build: cmake -DCMAKE_BUILD_TYPE=Release ..
- Enable assembly optimization: -DCAL_USE_ASM_OPTIMIZATION=ON
- Use single precision (float) instead of double
- Enable compiler optimizations: -O3 -ffast-math

Problem: High memory usage

Solution: Reduce configuration limits
- Decrease CAL_SIN_TABLE_SIZE in cal_config.h
- Reduce CAL_MAX_MATRIX_SIZE
- Use smaller filter window sizes
- Disable unused modules in CMake

4. Numerical Issues (数值问题)

Problem: Matrix inversion fails with CAL_ERROR_SINGULAR_MATRIX

Solution: Check matrix condition
- Verify matrix is not singular (determinant ≠ 0)
- Check for numerical instability (very small/large values)
- Use double precision for ill-conditioned matrices
- Add regularization if needed

Problem: Filter output oscillates or diverges

Solution: Check filter parameters
- Verify sample time is correct
- Ensure filter coefficients are stable
- Check for numerical overflow/underflow
- Reduce filter order if unstable

5. Integration Issues (集成问题)

Problem: Linking errors with multiple translation units

Solution: Ensure proper header inclusion
- Include cal_types.h before other headers
- Don't define CAL_USE_DOUBLE_PRECISION inconsistently
- Use extern "C" for C++ projects

Problem: Assembly optimized code crashes

Solution: Check alignment and calling convention
- Ensure data is properly aligned (4-byte for float)
- Verify stack alignment for ARM EABI
- Check FPU is enabled in startup code
- Verify correct ARM architecture flags (-mcpu, -mfpu)

Enable Error Checking:

cal_error_t err = cal_function(...);
if (err != CAL_OK) {
    printf("Error: %d\n", err);
    // Handle error
}

Verify Input Ranges:

// Check for NaN or Inf
if (isnan(value) || isinf(value)) {
    // Handle invalid input
}

// Check parameter ranges
if (value < MIN_VALUE || value > MAX_VALUE) {
    // Handle out of range
}

Use Assertions in Debug Build:

#ifdef DEBUG
    assert(ptr != NULL);
    assert(size > 0);
    assert(value >= 0.0f && value <= 1.0f);
#endif

Monitor Numerical Stability:

// Check for overflow
if (fabs(value) > CAL_REAL_MAX * 0.1f) {
    // Value approaching overflow
}

// Check for underflow
if (fabs(value) < CAL_EPSILON) {
    // Value approaching zero
}

If you encounter issues not covered here:

1. Check the API documentation (Doxygen)
2. Review example code in examples/ directory
3. Check implementation documentation in docs/ directory
4. Enable verbose error messages and logging
5. Create a minimal reproducible example
6. Check compiler warnings and fix them

Using ARM Cortex-M DWT (Data Watchpoint and Trace):

// Enable DWT cycle counter
CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
DWT->CYCCNT = 0;
DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;

// Measure cycles
uint32_t start = DWT->CYCCNT;
clarke_transform(&abc, &alphabeta);
uint32_t cycles = DWT->CYCCNT - start;

Using gprof (Linux):

# Compile with profiling
gcc -pg your_program.c -o your_program -lcal -lm

# Run program
./your_program

# Generate profile
gprof your_program gmon.out > analysis.txt

[To be determined]

Contributions are welcome! Please follow these guidelines:

1. Code Style: Follow the existing code style (K&R style, 4 spaces indentation)
2. Documentation: Add Doxygen comments for all public APIs
3. Testing: Add unit tests for new algorithms
4. Examples: Provide usage examples for new features
5. Commit Messages: Use clear, descriptive commit messages

# Fork and clone the repository
git clone https://github.com/your-username/control-algorithms-library.git
cd control-algorithms-library

# Create a feature branch
git checkout -b feature/new-algorithm

# Make changes and test
mkdir build && cd build
cmake -DCAL_BUILD_TESTS=ON ..
cmake --build .
ctest

# Commit and push
git add .
git commit -m "Add new algorithm: XYZ"
git push origin feature/new-algorithm

# Create pull request

1. Create header file in include/cal_your_algorithm.h
2. Create source file in appropriate src/ subdirectory
3. Add unit tests in tests/unit/test_your_algorithm.c
4. Add usage example in examples/example_your_algorithm.c
5. Update CMakeLists.txt to include new files
6. Update this README with algorithm description
7. Add Doxygen documentation

Control Algorithms Library Team

• Unity Test Framework: https://github.com/ThrowTheSwitch/Unity
• CMake: https://cmake.org/
• ARM CMSIS: https://github.com/ARM-software/CMSIS_5

• CMSIS-DSP: ARM's DSP library for Cortex-M processors
• libfixmath: Fixed-point math library
• Eigen: C++ template library for linear algebra
• GNU Scientific Library (GSL): Numerical library for C/C++

• ✅ Core FOC algorithms (Clarke, Park, SVPWM)
• ✅ PID controller family
• ✅ Digital filters
• ✅ Power control algorithms
• ✅ Math library with CORDIC
• ✅ Matrix operations
• ✅ Signal processing (FFT, windows)
• ✅ ARM Cortex-M assembly optimizations
• ✅ Observers and estimators
• ✅ Advanced control (Fuzzy, Sliding Mode, MPC)

• ⏳ ARM Cortex-A NEON optimizations
• ⏳ RISC-V assembly optimizations
• ⏳ DSP processor optimizations (TI C2000)
• ⏳ Additional state-space control algorithms
• ⏳ More observer implementations
• ⏳ Torque ripple suppression algorithms
• ⏳ Additional signal processing algorithms
• ⏳ Python bindings for simulation
• ⏳ MATLAB/Simulink integration
• ⏳ Real-time operating system (RTOS) integration examples

• 🔮 Hardware acceleration support (FPGA, GPU)
• 🔮 Model-based code generation
• 🔮 Automatic parameter tuning tools
• 🔮 Web-based visualization and tuning interface
• 🔮 Machine learning integration for adaptive control

Q: Can I use this library in commercial products? A: Please check the license file for usage terms.

Q: Which ARM processors are supported? A: The library works on any ARM Cortex-M processor. Assembly optimizations are available for Cortex-M4/M7 with FPU.

Q: Can I use this library with Arduino? A: Yes, but you'll need to adapt the build system. The library is designed for bare-metal or RTOS environments.

Q: How do I choose between float and double precision? A: Use float (single precision) for embedded systems with hardware FPU. Use double for desktop applications or when higher accuracy is required.

Q: Is the library thread-safe? A: Algorithm instances are not thread-safe. Each thread should have its own instance, or use external synchronization.

Q: Can I use only specific algorithms without the entire library? A: Yes, the modular design allows you to include only the algorithms you need. Just copy the relevant .c/.h files and dependencies.

Q: How do I report bugs or request features? A: Please create an issue on the GitHub repository with detailed information.

Q: Are there Python bindings available? A: Not yet, but this is planned for future releases.

Comparison with other libraries (ARM Cortex-M4 @ 168MHz):

Note: Performance varies based on compiler, optimization level, and specific use case.

If you use this library in academic work, please cite:

@software{control_algorithms_library,
  title = {Control Algorithms Library},
  author = {Control Algorithms Library Team},
  year = {2024},
  url = {https://github.com/your-org/control-algorithms-library}
}

• Issues: GitHub Issues
• Discussions: GitHub Discussions
• Email: [To be determined]

Note: This library is under active development. APIs may change in future versions. Please check the changelog for breaking changes.

注意: 本库正在积极开发中。API可能在未来版本中发生变化。请查看更新日志了解破坏性更改。