Control Application Compilation for Cross-Hardware Debugging
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing control systems face inefficiencies due to device dependency in development environments, making it difficult to debug executable code before conversion to high-level languages, and require proficiency in multiple environments for different target hardware.
Innovation Solution
An engineering apparatus that converts control logic and data from a first programming language into a second programming language, allowing for debugging of executable code before conversion, using an algorithm converter, type management unit, instance management unit, and build controller to generate executable code using a compiler or linker for the target hardware.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If control applications are converted to high-level languages using existing methods, then device dependency is reduced, but debugging capability before conversion is lost
Solution Approach 1:
The patent performs preliminary compilation of the control application into executable code before final conversion to high-level language. This intermediate executable code enables debugging operations to be performed on the actual target hardware architecture while maintaining the ability to later convert to device-independent high-level language, thus preserving both debugging capability and device independence.
Solution Approach 2:
The patent introduces an intermediary executable code format that serves as a bridge between the original control application and the final high-level language conversion. This intermediate representation allows debugging to occur on target hardware while the final output remains device-independent, resolving the contradiction between debugging capability and device independence.
2Adaptability or versatility
If multiple development environments are used for different target hardware, then compatibility with various devices is improved, but operator complexity increases
Solution Approach 1:
The patent creates a universal development environment that can compile control applications for multiple types of target hardware through a single interface. The system maintains a library of compiler/linker configurations for different hardware platforms and automatically selects the appropriate one, allowing one development environment to serve multiple hardware targets without requiring operators to learn multiple specialized environments.
Solution Approach 2:
The patent uses configurable parameters and settings within a single development environment to adapt to different target hardware platforms. By changing compilation parameters, linker settings, and hardware configuration options, the same development environment can be tuned to work with various processor architectures and hardware configurations, eliminating the need for multiple specialized environments.
3Productivity
If control applications are compiled directly to executable code, then execution efficiency is improved, but flexibility for cross-platform execution is reduced
Solution Approach 1:
The patent segments the compilation process into distinct phases: first compiling the control application into executable code for efficiency, then separately converting to high-level language for cross-platform flexibility. This segmentation allows each phase to optimize for its specific purpose - the compilation phase for execution efficiency and the conversion phase for portability.
Solution Approach 2:
The patent makes the compilation and conversion process dynamic and configurable, allowing users to choose when to compile to executable code and when to convert to high-level language based on the specific needs of each project. This dynamic approach enables optimization for either execution efficiency or cross-platform flexibility depending on the situation.
Data Source
AI summary
An engineering apparatus according to the present disclosure generates generating executable code, which causes target hardware to operate, from a control application. The engineering apparatus includes an algorithm converter that converts control logic included in the control application into control logic code, a type management unit that outputs a type definition code corresponding to a data block structure of data held by a function block included in the control application, an instance management unit that outputs a memory allocation code that allocates an instance of the function block to memory, and a build controller that generates the executable code based on the control logic code, the type definition code, and the memory allocation code. Executable code for execution by target hardware is debugged while the executable code is in the form of a control application before conversion to a high-level language.