Hello guys, welcome back to our blog. In this article, I will discuss code generation in MATLAB Simulink and things to be followed for efficient code generation.

Ask questions if you have any electrical, electronics, or computer science doubts. You can also catch me on Instagram – CS Electrical & Electronics

Code Generation In MATLAB Simulink

MATLAB Simulink is a powerful tool used in Model-Based Design (MBD) to develop and simulate control algorithms, signal processing, and embedded systems. Code generation from Simulink models is crucial for deploying these algorithms to real-time hardware platforms efficiently. To achieve optimal performance, it is essential to follow a systematic approach that ensures the generated code is efficient, maintainable, and meets the desired performance criteria.

This article outlines the essential steps to be followed for efficient code generation from MATLAB Simulink, covering best practices, optimization techniques, and considerations for embedded system deployment.

01. Modeling Best Practices

A well-structured and optimized Simulink model is fundamental to generating efficient code. Follow these best practices:

a. Adopt a Modular Approach

Divide the model into subsystems and reusable components.
Use libraries and referenced models for scalability and maintainability.
Keep blocks and subsystems as simple as possible for easy debugging and testing.

b. Use Atomic Subsystems

Ensure subsystems are set to atomic for independent execution and efficient code generation.
This prevents redundant computations and optimizes scheduling.
Enable the “Function Packaging” option in Simulink to control subsystem implementation in the generated code.

c. Optimize Signal Routing

Minimize unnecessary signal routing by using direct connections.
Avoid implicit signal conversion, which can increase computational overhead.
Use bus signals instead of multiple separate signals to enhance efficiency.

d. Minimize Block Usage and Redundant Computation

Replace expensive computational blocks with simpler alternatives whenever possible.
Use lookup tables instead of complex mathematical operations where applicable.
Reduce redundant computations by sharing calculations across multiple blocks.

02. Selecting an Appropriate Solver

The choice of solver significantly impacts execution time and efficiency:

a. Fixed-Step vs. Variable-Step Solvers

For real-time applications, use fixed-step solvers to ensure deterministic behavior.
Variable-step solvers are suitable for simulations but may lead to inefficiencies in generated code.
Adjust solver step sizes according to system dynamics to balance accuracy and performance.

b. Discrete vs. Continuous-Time Models

Discrete models result in more efficient code since they align well with digital controllers.
Continuous models require numerical integration, increasing computational complexity.
When using continuous systems, employ solver optimizations like zero-crossing detection to enhance efficiency.

03. Configuring Model Settings for Code Generation

MATLAB Simulink provides various settings to optimize code generation:

a. Set Code Generation Target

Use Embedded Coder for optimized C/C++ code generation.
Select the appropriate hardware support package for target deployment.
Enable optimizations like MAT-file logging suppression for production code.

b. Optimization Settings

Enable Signal Storage Reuse to minimize memory usage.
Use Inline Parameters to replace block parameters with constants.
Optimize Loop Rolling and Unrolling for efficient execution.
Leverage Shared Utility Code to reuse functions and avoid redundant implementations.
Enable Remove Unused Variables to ensure only necessary variables are retained in the final code.

c. Execution Order Control

Ensure proper data dependency in blocks to minimize unnecessary function calls.
Use the “Update Diagram” feature to check for unintended dependencies before code generation.

04. Data Types and Memory Management

Efficient memory management is critical for embedded systems:

a. Use Fixed-Point Arithmetic

Floating-point operations consume more resources; use fixed-point whenever possible.
MATLAB’s Fixed-Point Designer helps in automatic data type conversion.
Use fraction length and word length optimizations to ensure accuracy with minimal bit usage.

b. Avoid Unnecessary Data Type Conversions

Explicitly define data types instead of relying on implicit conversions.
Use single or int types based on hardware constraints.
Ensure consistent data type usage across subsystems to prevent type mismatches.

05. Code Generation and Verification

Once the model is optimized, proceed with code generation and verification:

a. Generate and Analyze Code

Use the Simulink Coder to generate C/C++ code.
Analyze the generated code using the Code Generation Advisor.
Enable Static Code Metrics analysis to ensure maintainability and performance.

b. Run Software-in-the-Loop (SiL) and Processor-in-the-Loop (PiL) Tests

SiL testing helps validate functional correctness in a simulated environment.
PiL testing ensures that code execution behaves as expected on the target processor.
Compare PiL execution timing with hardware profiling tools to ensure real-time compliance.

06. Hardware Considerations

To ensure compatibility and efficiency, consider hardware constraints:

a. Memory and Processing Power Limitations

Optimize memory footprint to fit within available RAM and ROM.
Ensure code execution meets real-time constraints of the microcontroller.
Use Memory Sections settings to allocate memory effectively.

b. Use Hardware-Specific Optimizations

Utilize vendor-specific libraries and compilers (e.g., ARM Cortex-M, Texas Instruments C2000).
Leverage DSP blocks for signal processing applications.
Use Code Replacement Libraries (CRL) for processor-specific optimizations.

07. Code Profiling and Performance Analysis

Post-generation analysis is necessary for identifying performance bottlenecks:

a. Profiling Using Execution-Time Analysis

Use the Execution Profiler to measure task execution times.
Identify functions that consume excessive CPU time.
Utilize MATLAB’s tic-toc function to measure execution durations.

b. Optimize Memory and Execution Speed

Reduce redundant computations by optimizing algorithm implementation.
Minimize global variables and use local variables where possible.
Utilize MATLAB’s coder.extrinsic function to offload computations to MATLAB workspace when necessary.

08. Deploying the Generated Code

The final step is deploying the generated code to the embedded target:

a. Generate Makefiles and Build System Configuration

Ensure Makefile generation is enabled for streamlined compilation.
Configure the compiler and linker settings appropriately.
Use Incremental Builds to speed up the development cycle.

b. Perform Hardware Testing

Validate performance by testing the deployed application in real-world scenarios.
Ensure compliance with industry safety standards (e.g., ISO 26262 for automotive applications).
Conduct Hardware-in-the-Loop (HiL) testing for high-fidelity verification.

Conclusion

Efficient code generation from MATLAB Simulink requires careful model structuring, solver selection, optimization techniques, and thorough verification. By following the best practices outlined in this article, developers can generate high-performance code suitable for real-time embedded applications, reducing computational overhead and improving execution efficiency. Implementing these techniques ensures that the final code is optimized for execution speed, memory consumption, and overall system reliability.

This was about “Code Generation In MATLAB Simulink, Things To Be Followed For Efficient Code Generation“. Thank you for reading.

Also, read:

About The Author

Chetan Shidling

Automotive | Technical Blogger | Engineer | Content Creator

See author's posts

Share Now