Graphical Programming for Reconfigurable Hardware Communications
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Traditional text-based programming environments require users to possess advanced programming skills, creating a barrier for non-technical individuals in effectively utilizing computers and implementing processes, as they often require mastering different skills for conceptualization and implementation, leading to reduced efficiency.
Innovation Solution
A graphical programming environment is used to program communications packets onto reconfigurable hardware, such as FPGAs, allowing users to create graphical programs by arranging nodes and connecting them in data, control, or execution flow formats, which are then translated into hardware, enabling intuitive and efficient programming.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If text-based programming environments are used, then programming functionality is achieved, but user accessibility deteriorates due to requiring advanced programming skills
Solution Approach 1:
The patent replaces text-based programming mechanics with graphical programming mechanics. Instead of requiring users to write and compile text code, the system allows users to create programs by dragging and dropping graphical icons and connecting them with wires, substituting the mechanical act of text editing with visual manipulation. This resolves the contradiction by making programming accessible to non-technical users while maintaining full programming functionality.
Solution Approach 2:
The patent uses graphical icons that represent programming constructs as visual copies or metaphors of real-world concepts. For example, a thermometer icon represents temperature measurement, and a fan icon represents cooling functionality. These graphical copies allow users to conceptualize and implement solutions using familiar visual representations rather than abstract text syntax, improving ease of operation without sacrificing programming capability.
2Ease of operation
If graphical programming environments are used, then ease of operation improves through visual interfaces, but implementation complexity increases due to translating conceptual models to executable code
Solution Approach 1:
The graphical programming environment performs automatic code generation and compilation without requiring user intervention in the translation process. When users connect graphical icons with wires to define data flow, the system automatically generates the corresponding executable code, handles syntax construction, and manages compilation. This self-service mechanism eliminates the complexity of manual translation while preserving the visual programming benefits.
Solution Approach 2:
The patent introduces an automatic code generator as an intermediary between the graphical programming interface and the executable code. This intermediary layer translates the visual icon-wire representation into proper programming syntax automatically, shielding users from translation complexity while enabling full implementation of the conceptual model.
3Productivity
If automatic code generation is implemented, then productivity increases for non-technical users, but system complexity increases in the compilation process
Solution Approach 1:
The system performs preliminary analysis and validation of the graphical program structure during the icon placement and wire connection phases, before actual code generation occurs. The compilation process checks for logical errors, incomplete connections, and structural issues in advance, generating appropriate error messages that guide users to correct their graphical programs. This preliminary action approach increases productivity by providing immediate feedback while managing system complexity through structured validation routines.
Data Source
AI summary
In some embodiments, a user may select an elemental function such as read, write, or configuration from a graphical programming environment. A file may be created that instantiates functionality into a programmable hardware element to allow it to send a command across a serial protocol to peripheral interface circuitry and ultimately to peripheral chips (e.g., network chips on a CAN). The elemental node concept may be generic to any network chip because the node may contain only the general data of a packet (e.g., command type, value of data bytes, etc). The actual interface to a network chip may be handled inside the peripheral interface circuitry. The peripheral interface circuitry may have the details of the network chip in which it interfaces and may abstract details of the network chip from the target programmable hardware element through the serial protocol.