Unified Build File for Graphical Program Code Generation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current methods for generating code from graphical programs, such as those used in Simulink and MATLAB environments, often require separate code generation for different processing entities, leading to complexity in implementing and configuring graphical models across dissimilar processing entities like general-purpose processors and programmable logic devices.
Innovation Solution
A computer-implemented method and system that create a single build file for a graphical program, with sections for executable code, communication interfaces, and configuration, allowing execution by both general-purpose processors and programmable logic devices, enabling seamless implementation and communication between these entities.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Manufacturing precision
If separate code generation is used for different processing entities, then code can be optimized for each specific processor, but the complexity of implementing and configuring graphical models increases
Solution Approach 1:
The build file is segmented into distinct sections: an executable code section for the processor, a configuration section for the programmable logic device, and a communication interface section. This segmentation allows each section to be optimized for its specific target while maintaining overall system coherence through the unified build file structure.
Solution Approach 2:
The unified build file serves multiple functions simultaneously: it generates processor executable code, configures programmable logic devices, and establishes communication interfaces. This multi-functionality eliminates the need for separate code generation processes for different processing entities, reducing implementation complexity while maintaining optimization capabilities.
2Adaptability or versatility
If multiple separate build files are created for processor and programmable logic device, then each can be configured independently, but the overall configuration process becomes more complex
Solution Approach 1:
The patent merges the processor build file and programmable logic device build file into a single unified build file. This combination allows independent configuration sections to coexist within one file, maintaining adaptability while simplifying the configuration process through a single download and execution operation.
Solution Approach 2:
The communication interface section acts as an intermediary within the unified build file, establishing standardized interfaces between the processor and programmable logic device. This intermediary structure enables independent configuration of each component while ensuring they work together seamlessly through predefined communication protocols.
3Reliability
If separate executable files are generated for processor and programmable logic device, then each can be optimized for its architecture, but the deployment and communication setup becomes more complex
Solution Approach 1:
The unified build file is segmented into architecture-specific sections that can be independently optimized for each processing entity. The executable code section is optimized for the processor architecture, while the configuration section is optimized for the programmable logic device architecture, maintaining reliability through architecture-specific optimization.
Solution Approach 2:
The unified build file serves as a universal deployment package that handles multiple architecture-specific optimizations within a single file. It contains processor-specific executable code, device-specific configuration data, and communication interface definitions, eliminating the need for separate deployment processes for different architectures.
Data Source
AI summary
A system and method configures a target processing entity having multiple processing elements to execute a graphical program. A first part of the graphical program is designated for execution by a first processing element, and a second part of the graphical program is designed for execution by a second processing element. A code generation system generates a single build file from the graphical program having an initialization section, suitable executable code sections for each processing element, and a communication section that supports communication between the two processing elements. The build file may be downloaded to, and run by the target processing entity to implement the graphical program at the target processing entity.