Specifying and targeting portions of a graphical program for real-time response

CONTINUATION DATA

[0001] This application is a continuation of U.S. patent application Ser. No. 09/788,104 filed on Feb. 15, 2001 titled “System and Method for Configuring a Device to Perform Measurement Functions Utilizing Conversion of Graphical Programs into Hardware Implementations”, whose inventors are Jeffrey L. Kodosky, Hugo Andrade, Brian Keith Odom and Cary Paul Butler, which is a continuation of U.S. patent application Ser. No. 08/912,427 filed on Mar. 22, 2000 titled “System and Method for Converting Graphical Programs Into Hardware Implementations”, whose inventors are Jeffrey L. Kodosky, Hugo Andrade, Brian Keith Odom and Cary Paul Butler, which issued as U.S. Patent. No. 6,219,628 on Apr. 17, 2001, and which is a Continued Prosecution Application of U.S. patent application Ser. No. 08/912,427 filed on Aug. 18, 1997 titled “System and Method for Converting Graphical Programs Into Hardware Implementations”, whose inventors are Jeffrey L. Kodosky, Hugo Andrade, Brian Keith Odom and Cary Paul Butler.

RESERVATION OF COPYRIGHT

[0002] A portion of the disclosure of this patent document contains material to which a claim of copyright protection is made. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure as it appears in the Patent and Trademark Office patent file or records, but reserves all other rights whatsoever.

FIELD OF THE INVENTION

[0003] The present invention relates to graphical programming, and in particular to a system and method for converting a graphical program into a programmable hardware implementation.

DESCRIPTION OF THE RELATED ART

[0004] Traditionally, high level text-based programming languages have been used by programmers in writing applications programs. Many different high level programming languages exist, including BASIC, C, FORTRAN, Pascal, COBOL, ADA, APL, etc. Programs written in these high level languages are translated to the machine language level by translators known as compilers. The high level programming languages in this level, as well as the assembly language level, are referred to as text-based programming environments.

[0005] Increasingly computers are required to be used and programmed by those who are not highly trained in computer programming techniques. When traditional text-based programming environments are used, the user's programming skills and ability to interact with the computer system often become a limiting factor in the achievement of optimal utilization of the computer system.

[0006] There are numerous subtle complexities which a user must master before he can efficiently program a computer system in a text-based environment. The task of programming a computer system to model a process often is further complicated by the fact that a sequence of mathematical formulas, mathematical steps or other procedures customarily used to conceptually model a process often does not closely correspond to the traditional text-based programming techniques used to program a computer system to model such a process. In other words, the requirement that a user program in a text-based programming environment places a level of abstraction between the user's conceptualization of the solution and the implementation of a method that accomplishes this solution in a computer program. Thus, a user often must substantially master different skills in order to both conceptually model a system and then to program a computer to model that system. Since a user often is not fully proficient in techniques for programming a computer system in a text-based environment to implement his model, the efficiency with which the computer system can be utilized to perform such modeling often is reduced.

[0007] Examples of fields in which computer systems are employed to model and/or control physical systems are the fields of instrumentation, process control, and industrial automation. Computer modeling or control of devices such as instruments or industrial automation hardware has become increasingly desirable in view of the increasing complexity and variety of instruments and devices available for use. However, due to the wide variety of possible testing/control situations and environments, and also the wide array of instruments or devices available, it is often necessary for a user to develop a program to control a desired system. As discussed above, computer programs used to control such systems had to be written in conventional text-based programming languages such as, for example, assembly language, C, FORTRAN, BASIC, or Pascal. Traditional users of these systems, however, often were not highly trained in programming techniques and, in addition, traditional text-based programming languages were not sufficiently intuitive to allow users to use these languages without training. Therefore, implementation of such systems frequently required the involvement of a programmer to write software for control and analysis of instrumentation or industrial automation data. Thus, development and maintenance of the software elements in these systems often proved to be difficult.

[0008] U.S. Pat. No. 4,901,221 to Kodosky et al discloses a graphical system and method for modeling a process, i.e. a graphical programming environment which enables a user to easily and intuitively model a process. The graphical programming environment disclosed in Kodosky et al can be considered the highest and most intuitive way in which to interact with a computer. A graphically based programming environment can be represented at level above text-based high level programming languages such as C, Pascal, etc. The method disclosed in Kodosky et al allows a user to construct a diagram using a block diagram editor, such that the diagram created graphically displays a procedure or method for accomplishing a certain result, such as manipulating one or more input variables to produce one or more output variables. In response to the user constructing a data flow diagram or graphical program using the block diagram editor, machine language instructions are automatically constructed which characterize an execution procedure which corresponds to the displayed procedure. Therefore, a user can create a computer program solely by using a graphically based programming environment. This graphically based programming environment may be used for creating virtual instrumentation systems, industrial automation systems and modeling processes, as well as for any type of general programming.

[0009] Therefore, Kodosky et al teaches a graphical programming environment wherein a user places on manipulates icons in a block diagram using a block diagram editor to create a data flow “program.” A graphical program for controlling or modeling devices, such as instruments, processes or industrial automation hardware, is referred to as a virtual instrument (VI). In creating a virtual instrument, a user preferably creates a front panel or user interface panel. The front panel includes various front panel objects, such as controls or indicators that represent the respective input and output that will be used by the graphical program or VI, and may include other icons which represent devices being controlled. When the controls and indicators are created in the front panel, corresponding icons or terminals are automatically created in the block diagram by the block diagram editor. Alternatively, the user can first place terminal icons in the block diagram which cause the display of corresponding front panel objects in the front panel. The user then chooses various functions that accomplish his desired result, connecting the corresponding function icons between the terminals of the respective controls and indicators. In other words, the user creates a data flow program, referred to as a block diagram, representing the graphical data flow which accomplishes his desired function. This is done by wiring up the various function icons between the control icons and indicator icons. The manipulation and organization of icons in turn produces machine language that accomplishes the desired method or process as shown in the block diagram.

[0010] A user inputs data to a virtual instrument using front panel controls. This input data propagates through the data flow block diagram or graphical program and appears as changes on the output indicators. In an instrumentation application, the front panel can be analogized to the front panel of an instrument. In an industrial automation application the front panel can be analogized to the MMI (Man Machine Interface) of a device. The user adjusts the controls on the front panel to affect the input and views the output on the respective indicators.

[0011] Thus, graphical programming has become a powerful tool available to programmers. Graphical programming environments such as the National Instruments LabVIEW product have become very popular. Tools such as LabVIEW have greatly increased the productivity of programmers, and increasing numbers of programmers are using graphical programming environments to develop their software applications. In particular, graphical programming tools are being used for test and measurement, data acquisition, process control, man machine interface (MMI), and supervisory control and data acquisition (SCADA) applications, among others.

[0012] A primary goal of virtual instrumentation is to provide the user the maximum amount of flexibility to create his/her own applications and/or define his/her own instrument functionality. In this regard, it is desirable to extend the level at which the user of instrumentation or industrial automation hardware is able to program instrument. The evolution of the levels at which the user has been able to program an instrument is essentially as follows.

[0013] 1. User level software (LabVIEW, LabWindows CVI, Visual Basic, etc.)

[0014] 2. Kernel level software

[0015] 3. Auxiliary kernel level software (a second kernel running along side the main OS, e.g., InTime, VentureCom, etc.)

[0016] 4. Embedded kernel level software (U.S. patent application Ser. No. 08/912,445, referenced herein)

[0017] 5. Hardware level software (FPGA—the present patent application)

[0018] In general, going down the above list, the user is able to create software applications which provide a more deterministic real-time response. Currently, most programming development tools for instrumentation or industrial automation provide an interface at level 1 above. In general, most users are unable and/or not allowed to program at the kernel level or auxiliary kernel level. The user level software typically takes the form of software tools that can be used to create software which operates at levels 1 and/or 4.

[0019] Current instrumentation solutions at level 5 primarily exist as vendor-defined solutions, i.e., vendor created modules. However, it would be highly desirable to provide the user with the ability to develop user level software which operates at the hardware level. More particularly, it would be desirable to provide the user with the ability to develop high level software, such as graphical programs, which can then be readily converted into hardware level instrument functionality. This would provide the user with the dual benefits of being able to program instrument functionality at the highest level possible (text-based or graphical programs), while also providing the ability to have the created program operate directly in hardware for increased speed and efficiency.

SUMMARY OF THE INVENTION

[0020] The present invention comprises a computer-implemented system and method for automatically generating hardware level functionality, e.g., programmable hardware or FPGAs, in response to a graphical program created by a user. This provides the user the ability to develop or define instrument functionality using graphical programming techniques, while enabling the resulting program to operate directly in hardware.

[0021] The user first creates a graphical program which performs or represents the desired functionality. The graphical program will typically include one or more modules or a hierarchy of sub-VIs. In the preferred embodiment, the user places various constructs in portions of the graphical program to aid in conversion of these portions into hardware form.

[0022] The user then selects an option to convert the graphical program into executable form, wherein at least a portion of the graphical program is converted into a hardware implementation. According to one embodiment of the present invention, the user can select which portions of modules are to be translated into hardware form, either during creation of the graphical program or when selecting the option to convert the graphical program into executable form. Thus the user can select a first portion of the graphical program, preferably comprising the supervisory control and display portion of the program, to be compiled into machine language for execution on a CPU. According to the present invention, the user can select a second portion of the graphical program which is desired for hardware implementation.

[0023] The portion of the graphical program selected for hardware implementation is first exported into a hardware description, such as a VHDL description. The hardware description is then converted into a net list, preferably an FPGA-specific net list. The hardware description is converted into a net list by a synthesis tool. The net list is then compiled into a FPGA program file, also called a software bit stream. In the preferred embodiment, the hardware description is directly converted into an FPGA program file.

[0024] The step of compiling the resulting net list into an FPGA program file preferably uses a library of pre-compiled function blocks to aid in the compilation, as well as hardware target specific information. The library of pre-compiled function blocks includes net list libraries for structure nodes, such as for/next loops, while/do loops, case structures, and sequence structures, among others. This allows the user to program with high level programming constructs, such as iteration, looping, and case structures, while allowing the resulting program to execute directly in hardware.

[0025] The resulting bit stream is then transferred to an FPGA to produce a programmed FPGA equivalent to the graphical program or block diagram.

[0026] The preferred embodiment of the invention comprises a general purpose computer system which includes a CPU and memory, and an interface card or device coupled to the computer system which includes programmable hardware or logic, such as an FPGA. The computer system includes a graphical programming system which is used to develop the graphical program. The computer system also includes software according to the present invention which is operable to convert the graphical program into a hardware description. The computer system further includes a synthesis tool which is used to compile the hardware description into an FPGA-specific net list, as well as other tools for converting the net list into an FPGA program file for downloading into the FPGA. The computer system further includes a library of pre-compiled function blocks according to the present invention which are used by the synthesis tool to aid in compiling the net list into the software bit stream.

[0027] In one embodiment, the target device including the reconfigurable hardware or FPGA being programmed comprises an interface card in the computer system, such as a data acquisition card, a GPIB interface card, or a VXI interface card. In an alternate embodiment, the target device being programmed comprises an instrument or device connected to the computer, such as through a serial connection. It is noted that the target instrument or device being programmed, which includes an FPGA or other configurable hardware element, can take any of various forms, as desired.

BRIEF DESCRIPTION OF THE DRAWINGS

[0028] A better understanding of the present invention can be obtained when the following detailed description of the preferred embodiment is considered in conjunction with the following drawings, in which:

[0029]FIG. 1 illustrates an instrumentation control system;

[0030]FIG. 1A illustrates an industrial automation system;

[0031]FIG. 2 is a block diagram of the instrumentation control system of FIG. 1;

[0032]FIGS. 3, 3A and <b>3</b>B are block diagrams illustrating an interface card configured with programmable hardware according to various embodiments of the present invention;

[0033]FIG. 4 is a flowchart diagram illustrating operation of the present invention;

[0034]FIG. 4A is a more detailed flowchart diagram illustrating operation of the preferred embodiment of the invention, including compiling a first portion of the graphical program into machine language and converting a second portion of the graphical program into a hardware implementation;

[0035]FIG. 5 is a more detailed flowchart diagram illustrating creation of a graphical program according to the preferred embodiment;

[0036]FIG. 6 is a more detailed flowchart diagram illustrating operation of exporting at least a portion of a graphical program to a hardware description;

[0037]FIG. 7 is a flowchart diagram illustrating operation where the method exports an input terminal into a hardware description;

[0038]FIG. 8 is a flowchart diagram illustrating operation where the method exports a function node into a hardware description;

[0039]FIG. 9 is a flowchart diagram illustrating operation where the method exports an output terminal into a hardware description;

[0040]FIG. 10 is a flowchart diagram illustrating operation where the method exports a structure node into a hardware description;

[0041]FIG. 11 illustrates converting a node hardware description to a net list;

[0042]FIG. 12 illustrates converting a structure node hardware description to a net list;

[0043]FIG. 13 illustrates the function block for a structure node;

[0044]FIG. 14 is a state diagram illustrating operation of the structure node function block of FIG. 13;

[0045]FIGS. 15 and 16 illustrate a simple example of operation of the present invention, wherein FIG. 15 illustrates a simple graphical program and FIG. 16 is a conceptual diagram of the hardware description of the graphical program of FIG. 15; and

[0046] FIGS. <b>17</b>-<b>19</b> illustrate another example of operation of the present invention, wherein FIG. 17 illustrates a graphical program, FIG. 18 illustrates a tree of data structures created in response to the graphical program of FIG. 17, and FIG. 18 is a conceptual diagram of the hardware description of the graphical program of FIG. 17.

[0047] While the invention is susceptible to various modifications and alternative forms specific embodiments are shown by way of example in the drawings and will herein be described in detail. It should be understood however, that drawings and detailed description thereto are not intended to limit the invention to the particular form disclosed. But on the contrary the invention is to cover all modifications, equivalents and alternative following within the spirit and scope of the present invention as defined by the appended claims.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT

[0048] Incorporation by Reference

[0049] The following U.S. Patents and patent applications are hereby incorporated by reference in their entirety as though fully and completely set forth herein.

[0050] U.S. Pat. No. 4,901,221 titled “Graphical System for Modeling a Process and Associated Method,” issued on Feb. 13, 1990.

[0051] U.S. Pat. No. 4,914,568 titled “Graphical System for Modeling a Process and Associated Method,” issued on Apr. 3, 1990.

[0052] U.S. Pat. No. 5,481,741 titled “Method and Apparatus for Providing Attribute Nodes in a Graphical Data Flow Environment”.

[0053] U.S. patent application Ser. No. 08/292,091 filed Aug. 17, 1994, titled “Method and Apparatus for Providing Improved Type Compatibility and Data Structure Organization in a Graphical Data Flow Diagram”.

[0054] U.S. Pat. No. 5,475,851 titled “Method and Apparatus for Improved Local and Global Variable Capabilities in a Graphical Data Flow Program”.

[0055] U.S. Pat. No. 5,497,500 titled “Method and Apparatus for More Efficient Function Synchronization in a Data Flow Program”.

[0056] U.S. patent application Ser. No. 08/474,307 titled “Method and Apparatus for Providing Stricter Data Type Capabilities in a Graphical Data Flow Environment” filed Jun. 7, 1995.

[0057] U.S. Pat. No. 5,481,740 titled “Method and Apparatus for Providing Autoprobe Features in a Graphical Data Flow Diagram”.

[0058] U.S. patent application Ser. No. 08/870,262 titled “System and Method for Detecting Differences in Graphical Programs” filed Jun. 6, 1997, whose inventor is Ray Hsu.

[0059] U.S. patent application Ser. No. 08/912,445 titled “Embedded Graphical Programming System” filed Aug. 18, 1997, whose inventors are Jeffrey L. Kodosky, Darshan Shah, Samson DeKey, and Steve Rogers, which issued as U.S. Pat. No. 6,173,438 on Jan. 9, 2001.

[0060] U.S. patent application Ser. No. 08/912,427 filed on Mar. 22, 2000 titled “System and Method for Converting Graphical Programs Into Hardware Implementations”, whose inventors are Jeffrey L. Kodosky, Hugo Andrade, Brian Keith Odom and Cary Paul Butler, which issued as U.S. Pat. No. 6,219,628 on Apr. 17, 2001.

[0061] The above-referenced patents and patent applications disclose various aspects of the LabVIEW graphical programming and development system.

[0062] The LabVIEW and BridgeVIEW graphical programming manuals, including the “G Programming Reference Manual”, available from National Instruments Corporation, are also hereby incorporated by reference in their entirety.

[0063]FIGS. 1 and 1A—Instrumentation and Industrial Automation Systems

[0064] Referring now to FIG. 1, an instrumentation control system <b>100</b> is shown. The system <b>100</b> comprises a computer <b>102</b> which connects to one or more instruments. The computer <b>102</b> comprises a CPU, a display screen, memory, and one or more input devices such as a mouse or keyboard as shown. The computer <b>102</b> connects through the one or more instruments to analyze, measure or control a unit under test (UUT) or process <b>130</b>.

[0065] The one or more instruments may include a GPIB instrument <b>112</b>, a data acquisition board <b>114</b>, and/or a VXI instrument <b>116</b>. The GPIB instrument <b>112</b> is coupled to the computer <b>102</b> via a GPIB interface card <b>122</b> provided by the computer <b>102</b>. The data acquisition board <b>114</b> is coupled to the computer <b>102</b>, and preferably interfaces through signal conditioning circuitry <b>124</b> to the UUT. The signal conditioning circuitry <b>124</b> preferably comprises an SCXI (Signal Conditioning eXtensions for Instrumentation) chassis comprising one or more SCXI modules <b>126</b>. Both the GPIB card <b>122</b> and the DAQ card <b>114</b> are typically plugged in to an I/O slot in the computer <b>102</b>, such as a PCI bus slot, a PC Card slot, or an ISA, EISA or MicroChannel bus slot provided by the computer <b>102</b>. However, these cards <b>122</b> and <b>114</b> are shown external to computer <b>102</b> for illustrative purposes. The VXI instrument <b>116</b> is coupled to the computer <b>102</b> via a VXI bus, MXI bus, or other serial or parallel bus provided by the computer <b>102</b>. The computer <b>102</b> preferably includes VXI interface logic, such as a VXI, MXI or GPIB interface card (not shown) comprised in the computer. A serial instrument (not shown) may also be coupled to the computer <b>102</b> through a serial port, such as an RS-<b>232</b> port, USB (Universal Serial bus) or IEEE 1394 or 1394.2 bus, provided by the computer <b>102</b>. In typical instrumentation control systems an instrument will not be present of each interface type, and in fact many systems may only have one or more instruments of a single interface type, such as only GPIB instruments.

[0066] In the embodiment of FIG. 1, one or more of the devices connected to the computer <b>102</b> include programmable or reconfigurable hardware according to the present invention. For example, one or more of the GPIB card <b>122</b>, the DAQ card <b>114</b>, or the VXI card include programmable hardware according to the present invention. Alternatively, or in addition, one or more of the GPIB instrument <b>112</b>, the VXI instrument <b>116</b>, or the serial instrument include programmable hardware according to the present invention. In the preferred embodiment, the programmable hardware comprises an FPGA (field programmable gate array).

[0067] The instruments are coupled to the unit under test (UUT) or process <b>130</b>, or are coupled to receive field signals, typically generated by transducers. The system <b>100</b> may be used in a data acquisition and control application, in a test and measurement application, a process control application, or a man-machine interface application.

[0068] Referring now to FIG. 1A, an industrial automation system <b>140</b> is shown. The industrial automation system <b>140</b> is similar to the instrumentation or test and measurement system <b>100</b> shown in FIG. 1. Elements which are similar or identical to elements in FIG. 1 have the same reference numerals for convenience. The system <b>140</b> comprises a computer <b>102</b> which connects to one or more devices or instruments. The computer <b>102</b> comprises a CPU, a display screen, memory, and one or more input devices such as a mouse or keyboard as shown. The computer <b>102</b> connects through the one or more devices to a process or device <b>160</b> to perform an automation function, such as MMI (Man Machine Interface), SCADA (Supervisory Control and Data Acquisition), portable or distributed acquisition, advanced analysis, or control.

[0069] The one or more devices may include a data acquisition board <b>114</b>, a serial instrument <b>142</b>, a PLC (Programmable Logic Controller) <b>144</b>, or a fieldbus network card <b>156</b>. The data acquisition board <b>114</b> is coupled to or comprised in the computer <b>102</b>, and preferably interfaces through signal conditioning circuitry <b>124</b> to the process <b>160</b>. The signal conditioning circuitry <b>124</b> preferably comprises an SCXI (Signal Conditioning extensions for Instrumentation) chassis comprising one or more SCXI modules <b>126</b>. The serial instrument <b>142</b> is coupled to the computer <b>102</b> through a serial interface card <b>152</b>, or through a serial port, such as an RS-232 port, provided by the computer <b>102</b>. The PLC <b>144</b> couples to the computer <b>102</b> through a serial port, Ethernet port, or a proprietary interface. The fieldbus interface card <b>156</b> is preferably comprised in the computer <b>102</b> and interfaces through a fieldbus network to one or more fieldbus devices, such as valve <b>146</b>. Each of the DAQ card <b>114</b>, the serial card <b>152</b> and the fieldbus card <b>156</b> are typically plugged in to an I/O slot in the computer <b>102</b> as described above. However, these cards <b>114</b>, <b>12</b> and <b>156</b> are shown external to computer <b>102</b> for illustrative purposes. In typical industrial automation systems a device will not be present of each interface type, and in fact many systems may only have one or more devices of a single interface type, such as only PLCs. The devices are coupled to the device or process <b>160</b>.

[0070] In the embodiment of FIG. 1A, one or more of the devices connected to the computer <b>102</b> include programmable hardware according to the present invention. For example, one or more of the data acquisition board <b>114</b>, the serial instrument <b>142</b>, the serial interface card <b>152</b>, the PLC <b>144</b>, or the fieldbus network card <b>156</b> include programmable hardware according to the present invention. In the preferred embodiment, the programmable hardware comprises an FPGA (field programmable gate array).

[0071] Referring again to FIGS. 1 and 1A, the computer <b>102</b> preferably includes a memory media, such as a magnetic media, CD-ROM, or floppy disks <b>104</b>. The memory media preferably stores a graphical programming development system for developing graphical programs. The memory media also stores computer programs according to the present invention which are executable to convert at least a portion of a graphical program into a form for configuring or programming the programmable hardware or FPGA. The present invention includes a software program stored on a memory and/or hard drive of the computer <b>102</b> and executed by a CPU of the computer <b>102</b>. The CPU executing code and data from the memory thus comprises a means for converting graphical code into a hardware implementation according to the steps described below.

[0072] The instruments or devices in FIGS. 1 and 1A are controlled by graphical software programs, optionally a portion of which execute on the CPU of the computer <b>102</b>, and at least a portion of which are downloaded to the programmable hardware for hardware execution. The graphical software programs which perform data acquisition, analysis and/or presentation, e.g., for instrumentation control or industrial automation, are referred to as virtual instruments.

[0073] In the preferred embodiment, the present invention is comprised in the LabVIEW or BridgeVIEW graphical programming systems, hereafter collectively referred to as LabVIEW, available from National Instruments. Also, in the preferred embodiment, the term “LabVIEW” is intended to include graphical programming systems which include G programming functionality, i.e., which include at least a portion of LabVIEW graphical programming functionality, including the BridgeVIEW graphical programming system.

[0074] Also, the term “graphical programming system” is intended to include any of various types of systems which are used to develop or create graphical code or graphical programs, including LabVIEW and BridgeVIEW from National Instruments, Visual Designer from Intelligent Instrumentation, Hewlett-Packard's VEE (Visual Engineering Environment), Snap-Master by HEM Data Corporation, DASYLab by DasyTec, GFS DiaDem, and ObjectBench by SES (Scientific and Engineering Software), among others.

[0075] Although in the preferred embodiment the graphical programs and programmable hardware are involved with data acquisition/generation, analysis, and/or display, and for controlling or modeling instrumentation or industrial automation hardware, it is noted that the present invention can be used to create hardware implementations of graphical programs for a plethora of applications and are not limited to instrumentation or industrial automation applications. In other words, FIGS. 1 and 1A are exemplary only, and the present invention may be used in any of various types of systems. Thus, the system and method of the present invention is operable for automatically creating hardware implementations of graphical programs or graphical code for any of various types of applications, including general purpose software applications such as word processing, spreadsheets, network control, games, etc.

[0076] Computer Block Diagram

[0077] Referring now to FIG. 2, a block diagram of the computer <b>102</b> (of FIG. 1) is shown. The elements of a computer not necessary to understand the operation of the present invention have been omitted for simplicity. The computer <b>102</b> includes at least one central processing unit or CPU <b>160</b> which is coupled to a processor or host bus <b>162</b>. The CPU <b>160</b> may be any of various types, including an x86 processor, a PowerPC processor, a CPU from the Motorola family of processors, a CPU from the SPARC family of RISC processors, as well as others. Main memory <b>166</b> is coupled to the host bus <b>162</b> by means of memory controller <b>164</b>. The main memory <b>166</b> stores a graphical programming system, and also stores software for converting at least a portion of a graphical program into a hardware implementation. This software will be discussed in more detail below. The main memory <b>166</b> also stores operating system software as well as the software for operation of the computer system, as well known to those skilled in the art.

[0078] The host bus <b>162</b> is coupled to an expansion or input/output bus <b>170</b> by means of a bus controller <b>168</b> or bus bridge logic. The expansion bus <b>170</b> is preferably the PCI (Peripheral Component Interconnect) expansion bus, although other bus types can be used. The expansion bus <b>170</b> includes slots for various devices such as the data acquisition board <b>114</b> (of FIG. 1), a GPIB interface card <b>122</b> which provides a GPIB bus interface to the GPIB instrument <b>112</b> (of FIG. 1), and a VXI or MXI bus card <b>230</b> coupled to the VXI chassis <b>116</b> for receiving VXI instruments. The computer <b>102</b> further comprises a video display subsystem <b>180</b> and hard drive <b>182</b> coupled to the expansion bus <b>170</b>.

[0079] One or more of the interface cards or devices coupled to the expansion bus, such as the DAQ card <b>114</b>, the GPIB interface card <b>122</b>, the GPIB instrument <b>112</b>, or the VXI or MXI bus card <b>230</b> comprises an embedded system comprising an embedded CPU and embedded memory.

[0080] Programmable Hardware Diagram

[0081] Referring now to FIG. 3, a block diagram illustrating an interface card configured with programmable hardware according to the present invention is shown. It is noted that FIG. 3 is exemplary only, and an interface card or device configured with programmable hardware according to the present invention may have various architectures or forms, as desired. The interface card illustrated in FIG. 3 is the DAQ interface card <b>114</b> shown in either of FIG. 1 or <b>1</b>A. However, as noted above, the programmable hardware may be included on any of the various devices shown in FIG. 1 or <b>1</b>A, or on other devices, as desired.

[0082] As shown, the interface card <b>114</b> includes an I/O connector <b>202</b> which is coupled for receiving signals. In the embodiments of FIGS. 1 and 1A, the I/O connector <b>202</b> presents analog and/or digital connections for receiving/providing analog or digital signals. The I/O connector <b>202</b> is adapted for coupling to SCXI conditioning logic <b>124</b> and <b>126</b>, or is adapted to be coupled directly to a unit under test <b>130</b> or process <b>160</b>.

[0083] The interface card <b>114</b> also includes data acquisition (DAQ) logic <b>204</b>. As shown, the data acquisition logic <b>204</b> comprises analog to digital (A/D) converters, digital to analog (D/A) converters, timer counters (TC) and signal conditioning (SC) logic as shown. The DAQ logic <b>204</b> provides the data acquisition functionality of the DAQ card <b>114</b>.

[0084] According to the preferred embodiment of the invention, the interface card <b>114</b> includes a programmable hardware element or programmable processor <b>206</b>. In the preferred embodiment, the programmable hardware <b>206</b> comprises a field programmable gate array (FPGA) such as those available from Xilinx, Altera, etc. The programmable hardware element <b>206</b> is coupled to the DAQ logic <b>204</b> and is also coupled to the local bus interface <b>208</b>. Thus a graphical program can be created on the computer <b>102</b>, or on another computer in a networked system, and at least a portion of the graphical program can be converted into a hardware implementation form for execution in the FPGA <b>206</b>. The portion of the graphical program converted into a hardware implementation form is preferably a portion which requires fast and/or real-time execution

[0085] In the embodiment of FIG. 3, the interface card <b>114</b> further includes a dedicated on-board microprocessor <b>212</b> and memory <b>214</b>. This enables a portion of the graphical program to be compiled into machine language for storage in the memory <b>214</b> and execution by the microprocessor <b>212</b>. This is in addition to a portion of the graphical program being converted into a hardware implementation form in the FPGA <b>206</b>. Thus, in one embodiment, after a graphical program has been created, a portion of the graphical program is compiled for execution on the embedded CPU <b>212</b> and executes locally on the interface card <b>114</b> via the CPU <b>212</b> and memory <b>214</b>, and a second portion of the graphical program is translated or converted into a hardware executable format and downloaded to the FPGA <b>206</b> for hardware implementation.

[0086] As shown, the interface card <b>114</b> further includes bus interface logic <b>216</b> and a control/data bus <b>218</b>. In the preferred embodiment, the interface card <b>114</b> is a PCI bus-compliant interface card adapted for coupling to the PCI bus of the host computer <b>102</b>, or adapted for coupling to a PXI (PCI eXtensions for Instrumentation) bus. The bus interface logic <b>216</b> and the control/data bus <b>218</b> thus present a PCI or PXI interface.

[0087] The interface card <b>114</b> also includes local bus interface logic <b>208</b>. In the preferred embodiment, the local bus interface logic <b>208</b> presents a RTSI (Real Time System Integration) bus for routing timing and trigger signals between the interface card <b>114</b> and one or more other devices or cards.

[0088] In the embodiment of FIG. 3A, the CPU <b>212</b> and memory <b>214</b> are not included on the interface card <b>114</b>, and thus only the portion of the graphical program which is converted into hardware implementation form is downloaded to the FPGA <b>206</b>. Thus in the embodiment of FIG. 3A, any supervisory control portion of the graphical program which is necessary or desired to execute in machine language on a programmable CPU is executed by the host CPU in the computer system <b>102</b>, and is not executed locally by a CPU on the interface card <b>114</b>.

[0089] In the embodiment of FIG. 3B, the CPU <b>212</b> is not included on the interface card <b>114</b>, i.e., the interface card <b>114</b> includes the FPGA <b>206</b> and the memory <b>214</b>. In this embodiment, the memory <b>214</b> is used for storing FPGA state information. FIG. 3B is the currently preferred embodiment of the present invention.

[0090]FIG. 4—Conversion of Graphical Code into a Hardware Implementation

[0091] Referring now to FIG. 4, a flowchart diagram is shown illustrating operation of the preferred embodiment of the present invention. The present invention comprises a computer-implemented method for generating hardware implementations of graphical programs or graphical code. It is noted that various of the steps in the flowcharts below can occur concurrently or in different orders.

[0092] The method below presumes that a graphical programming development system is stored in the memory of the computer system for creation of graphical programs. In the preferred embodiment, the graphical programming system is the LabVIEW graphical programming system available from National Instruments. In this system, the user creates the graphical program in a graphical program panel, referred to as a block diagram window and also creates a user interface in a graphical front panel. The graphical program is sometimes referred to as a virtual instrument (VI). The graphical program or VI will typically have a hierarchy of sub-graphical programs or sub-VIs.

[0093] As shown, in step <b>302</b> the user first creates a graphical program, also sometimes referred to as a block diagram. In the preferred embodiment, the graphical program comprises a graphical data flow diagram which specifies functionality of the program to be performed. This graphical data flow diagram is preferably directly compilable into machine language code for execution on a computer system.

[0094] In step <b>304</b> the method operates to export at least a portion of the graphical program to a hardware description. Thus, after the user has created a graphical program in step <b>302</b>, the user selects an option to export a portion of the graphical program to a hardware description. The hardware description is preferably a VHDL description, e.g., a VHDL source file, or alternatively is a high level net list description. The hardware description comprises a high level hardware description of function blocks, logic, inputs, and outputs which perform the operation indicated by the graphical program. The operation of exporting at least a portion of a the graphical program to a hardware description is discussed in more detail with the flowchart of FIG. 6.

[0095] In one embodiment, during creation of the graphical program in step <b>302</b> the user specifies portions, e.g. sub VIs, which are to be exported to the hardware description format for conversion into hardware implementation. In another embodiment, when the user selects the option to export a portion of the graphical program to the hardware description format, the user selects which modules or sub-VIs at that time which are to be exported to the hardware description.

[0096] In step <b>306</b> the method operates to convert the hardware description into an FPGA-specific net list. The net list describes the components required to be present in the hardware as well as their interconnections. Conversion of the hardware description into the FPGA-specific net list is preferably performed by any of various types of commercially available synthesis tools, such as those available from Xilinx, Altera, etc.

[0097] In the preferred embodiment, the converting step <b>306</b> may utilize one or more pre-compiled function blocks from a library of pre-compiled function blocks <b>308</b>. Thus, for certain function blocks which are difficult to compile, or less efficient to compile, from a hardware description into a net list format, the hardware description created in step <b>304</b> includes a reference to a pre-compiled function block from the library <b>308</b>. The respective pre-compiled function blocks are simply inserted into the net list in place of these references in step <b>306</b>. The preferred embodiment of the invention thus includes the library <b>308</b> of pre-compiled function blocks which are used in creating the net list. The preferred embodiment also includes hardware target specific information <b>310</b> which is used by step <b>306</b> in converting the hardware description into a net list which is specific to a certain type or class of FPGA.

[0098] In step <b>312</b> the method operates to compile the net list into an FPGA program file, also referred to as a software bit stream. The FPGA program file is a file that can be readily downloaded to program an FPGA.

[0099] After the net list has been compiled into an FPGA program file in step <b>312</b>, then in step <b>314</b> the method operates to transfer the FPGA program file to the programmable hardware, e.g., the FPGA, to produce a programmed hardware equivalent to the graphical program. Thus, upon completion of step <b>314</b>, the portion of a graphical program referenced in step <b>304</b> is comprised as a hardware implementation in an FPGA or other programmable hardware element.

[0100] It is noted that various of the above steps can be combined and/or can be made to appear invisible to the user. For example, steps <b>306</b> and <b>312</b> can be combined into a single step, as can steps <b>304</b> and <b>306</b>. In the preferred embodiment, after the user creates the graphical program in step <b>302</b>, the user simply selects a hardware export option and indicates the hardware target or destination, causing steps <b>304</b>-<b>314</b> to be automatically performed.

[0101]FIG. 4A—Conversion of a Graphical Program into Machine Language and Hardware Implementations

[0102]FIG. 4A is a more detailed flowchart diagram illustrating operation of the preferred embodiment of the invention, including compiling a first portion of the graphical program into machine language and converting a second portion of the graphical program into a hardware implementation.

[0103] As shown in FIG. 4A, after the user has created a graphical program in step <b>302</b>, the user can optionally select a first portion to be compiled into machine code for CPU execution as is normally done. In the preferred embodiment, the user preferably selects a supervisory control and display portion of the graphical program to be compiled into machine code for a CPU execution. The first portion comprising supervisory control and display portions is compiled for execution on a CPU, such as the host CPU in the computer <b>102</b> or the CPU <b>212</b> comprised on the interface card <b>114</b>. This enables the supervisory control and display portions to execute on the host CPU, which is optimal for these elements of the program.

[0104] The user selects a second portion for conversion to hardware implementation, which is performed as described above in steps <b>304</b>-<b>314</b> of FIG. 4. The portion of the graphical program which is desired for hardware implementation preferably comprises modules or VIs which require a fast or deterministic implementation and/or are desired to execute in a stand-alone hardware unit. In general, portions of the graphical program which are desired to have a faster or more deterministic execution are converted into the hardware implementation. In one embodiment, the entire graphical program is selected for conversion to a hardware implementation, and thus step <b>322</b> is not performed.

[0105]FIG. 5—Creation of a Graphical Program

[0106]FIG. 5 is a more detailed flowchart diagram of step <b>302</b> of FIGS. 4 and 4A, illustrating creation of a graphical program according to the preferred embodiment of the invention. As shown, in step <b>342</b> the user arranges on the screen a graphical program or block diagram. This includes the user placing and connecting, e.g., wiring, various icons or nodes on the display screen in order to configure a graphical program. More specifically, the user selects various function icons or other icons and places or drops the icons in a block diagram panel, and then connects or “wires up” the icons to assemble the graphical program. The user also preferably assembles a user interface, referred to as a front panel, comprising controls and indicators which indicate or represent input/output to/from the graphical program. For more information on creating a graphical program in the LabVIEW graphical programming system, please refer to the LabVIEW system available from National Instruments as well as the above patent applications incorporated by reference.

[0107] In response to the user arranging on the screen a graphical program, the method operates to develop and store a tree of data structures which represent the graphical program. Thus, as the user places and arranges on the screen function nodes, structure nodes, input/output terminals, and connections or wires, etc., the graphical programming system operates to develop and store a tree of data structures which represent the graphical program. More specifically, as the user assembles each individual node and wire, the graphical programming system operates to develop and store a corresponding data structure in the tree of data structures which represents the individual portion of the graphical program that was assembled. Thus, steps <b>342</b> and <b>344</b> are an iterative process which are repetitively performed as the user creates the graphical program.

[0108]FIG. 6—Exporting a Portion of the Graphical Program to a Hardware Description

[0109]FIG. 6 is a flowchart diagram of step <b>304</b> of FIGS. 4 and 4A, illustrating operation when the method exports a portion of the graphical program into a hardware description. The tree of data structures created and stored in step <b>344</b> preferably comprises a hierarchical tree of data structures based on the hierarchy and connectivity of the graphical program. As shown, in step <b>362</b> the method traverses the tree of data structures and in step <b>364</b> the method operates to translate each data structure into a hardware description format. In one embodiment, the method first flattens the tree of data structures prior to traversing the tree in step <b>362</b>.

[0110] In the present embodiment, a number of different function icons and/or primitives can be placed in a diagram or graphical program for conversion into a hardware implementation. These primitives include, but are not limited to, function nodes, constants, global variables, control and indicator terminals, structure nodes, and sub-VIs, etc. Function icons or primitives can be any data type, but in the current embodiment are limited to Integer or Boolean data types. Also, global variables are preferably comprised on a single global panel for convenience. If a VI appears multiple times, then the VI is preferably re-entrant and may have state information. If a VI is not re-entrant, then preferably multiple copies of the VI are created in hardware if the VI has no state information, otherwise it would be an error.

[0111] In the preferred embodiment, each node which is converted to a hardware description includes an Enable input, a Clear_Enable signal input, a master clock signal input and an Enable_Out or Done signal. The Enable input guarantees that the node executes at the proper time, i.e., when all of its inputs have been received. The Clear_Enable signal input is used to reset the node if state information remembers that the node was done. The Enable_Out or Done signal is generated when the node completes and is used to enable operation of subsequent nodes which receive an output from the node. Each node which is converted to a hardware description also includes the data paths depicted in the graphical program.

[0112] For While loop structures, Iteration structures, Sequence structures, and Case Structures, the respective structure is essentially abstracted to a control circuit or control block. The control block includes a diagram enable out for each sub-diagram and a diagram done input for each sub-diagram.

[0113] In addition to the above signals, e.g., the Enable input, the Clear_Enable signal input, the master clock signal input, and the Enable_Out or Done signal, all global variables have numerous additional signals, including CPU interface signals which are specific to the type of CPU and bus, but typically include data lines, address lines, clock, reset and device select signals. All VIs and sub-VIs also include CPU interface signals if they contain a global variable.

[0114] In the preferred embodiment, when an icon is defined for a VI used solely to represent a hardware resource connected to the FPGA, e.g., an A/D converter, with a number of inputs and outputs, a string control is preferably placed on the front panel labeled VHDL. In this case, the default text of the string control is placed in the text file created for the VHDL of the VI. Thus, in one embodiment, a library of VIs are provided each representing a physical component or resource available in or to the FPGA. As these VHDL files representing these VIs are used, the method of the present invention monitors their usage to ensure that each hardware resource is used only once in the hierarchy of VIs being exported to the FPGA. When the VHDL file is written, the contents of the string control are used to define the access method of that hardware resource.

[0115] The following is pseudo-code which describes the operations performed in the flowchart of FIG. 6:

[0116] GenCircuit (vi)

[0117] send GenCircuit to top level diagram of vi

[0118] Diagram: GenCircuit(d)

[0119] send GenCircuit to each constant in d

[0120] send GenCircuit to each node in d

[0121] send GenCircuit to each signal in d

[0122] Signal: GenCircuit(s)

[0123] declare type of signal s

[0124] BasicNode: GenCircuit(n)

[0125] declare type of component needed for n

[0126] declare AND-gate for enabling n (if needed)

[0127] list connections for all node inputs

[0128] list connections for all inputs to enabling AND-gate (if needed)

[0129] Constant:GenCircuit(c)

[0130] declare type and value of constant c

[0131] WhileLoopNode: GenCircuit(n)

[0132] declare while loop controller component

[0133] declare AND-gate for enabling n (if needed)

[0134] list connections for all node inputs

[0135] list connections for all inputs to enabling AND-gate (if needed)

[0136] declare type of each shift register component

[0137] list connections for all inputs to all shift registers

[0138] declare type of each tunnel component

[0139] list connections for all inputs to all tunnels

[0140] CaseSelectNode:GenCircuit (n)

[0141] declare case select controller component

[0142] declare AND-gate for enabling n (if needed)

[0143] list connections for all node inputs

[0144] list connections for all inputs to enabling AND-gate (if needed)

[0145] declare type of each tunnel component

[0146] list connections for all inputs to all tunnels

[0147] SequenceNode:GenCircuit (n)

[0148] declare sequence controller component

[0149] declare AND-gate for enabling n (if needed)

[0150] list connections for all node inputs

[0151] list connections for all inputs to enabling AND-gate (if needed)

[0152] declare type of each tunnel component

[0153] list connections for all inputs to all tunnels

[0154] SubVINode:GenCircuit (n)

[0155] send GenCircuit to the subVI of n

[0156] associate inputs &amp; outputs of subVI with those of n

[0157] declare AND-gate for enabling n (if needed)

[0158] list connections for all node inputs

[0159] list connections for all inputs to enabling AND-gate (if needed)

[0160] Referring to the above pseudo code listing, the method starts at the VI level (the top level) and begins generation of VHDL by sending a message to the top level diagram. The method in turn effectively provides a message from the diagram to each constant, each node, and each signal in the diagram.

[0161] For signals, the method then declares the signal type.

[0162] For basic nodes, the method declares a type of the component needed, and also declare an AND-gate with the proper number of inputs needed in order to enable itself. In other words, basic nodes declare an AND-gate with a number of inputs corresponding to the number of inputs received by the node. Here, optimization is preferably performed to minimize the number of inputs actually needed. For example, if a node has three inputs, the node does not necessarily need a three input AND-gate if two of those inputs are coming from a single node. As another example, if one input comes from node A and another input comes from node B, but node A also feeds node B, then the input from node A is not needed in the AND gate. Thus various types of optimization are performed to reduce the number of inputs to each AND gate. For the basic node, the method also lists the connections for all of its inputs as well as the connections for all inputs to the enabling AND-gate.

[0163] For a constant, the method simply declares the type and the value of the constant.

[0164] For a While loop, the method declares a While loop controller component. The method also declares an AND-gate, lists AND-gate inputs, and lists node inputs in a similar manner to the basic node described above. The method then declares the type for each shift register and includes a component for the shift register, and lists all the connections for the shift register inputs. If any tunnels are present on the While loop, the method declares the type of each tunnel component and list the connections for the inputs to the tunnels. For most tunnels, the method simply equivalences the signals for the inside and outside, without any effect.

[0165] The method proceeds in a similar manner for Case and Sequence structures. For Case and Sequence structures, the method declares a case select controller component or a sequence controller component, respectively. For both Case and Sequence structures, the method also declares an AND-gate, lists AND-gate inputs, and lists node inputs in a similar manner to the basic node described above. The method then declares the component needed for any tunnels and list the connections for the inputs to the tunnels.

[0166] For a sub-VI, the method sends a message to the sub-VI and associates inputs and outputs of the sub-VI with those of n. The method then declares an AND-gate, lists AND-gate inputs, and lists node inputs in a similar manner to the basic node described above.

[0167]FIG. 7—Exporting an Input Terminal into a Hardware Description

[0168]FIG. 7 is a flowchart diagram illustrating operation when the method exports an input terminal into the hardware description format. As shown, in step <b>402</b> the method determines if the data provided to the input terminal is input from a portion of the graphical program which will be executing on the CPU, i.e., the portion of the graphical program which is to be compiled into machine language for execution on the CPU, or whether the data is input from another portion of the graphical program that is also being transformed into a hardware implementation.

[0169] As shown, if the data input to the input terminal is determined in step <b>402</b> to be input from a portion of the graphical program being compiled for execution on the CPU, in step <b>406</b> the method creates a hardware description of a write register with a data input and data and control outputs. The write register is operable to receive data transferred by the host computer, i.e., generated by the compiled portion executing on the CPU. In step <b>408</b> the data output of the write register is connected for providing data output to other elements in the graphical program portion. In step <b>408</b> the control output of the write register is connected to other elements in the graphical program portion for controlling sequencing of execution, in order to enable the hardware description to have the same or similar execution order as the graphical program.

[0170] If the data is determined to not be input from a portion being compiled for execution on the CPU step in <b>402</b>, i.e., the data is from another node in the portion being converted into a hardware implementation, then in step <b>404</b> the method ties the data output from the prior node into this portion of the hardware description, e.g., ties the data output from the prior node into the input of dependent sub-modules as well as control path logic to maintain the semantics of the original graphical program.

[0171]FIG. 8—Exporting a Function Node into a Hardware Description

[0172]FIG. 8 is a flowchart diagram illustrating operation where the method exports a function node into the hardware description format. In the preferred embodiment, the term “function node” refers to any various types of icons or items which represent a function being performed. Thus, a function node icon represents a function being performed in the graphical program. Examples of function nodes include arithmetic function nodes, e.g., add, subtract, multiply, and divide nodes, trigonometric and logarithmic function nodes, comparison function nodes, conversion function nodes, string function nodes, array and cluster function nodes, file I/O function nodes, etc.

[0173] As shown in FIG. 8, in step <b>422</b> the method determines the inputs and outputs of the function node. In step <b>424</b> the method creates a hardware description of the function block corresponding to the function node with the proper number of inputs and outputs as determined in step <b>422</b>. Alternatively, in step <b>424</b> the method includes a reference in the hardware description to a pre-compiled function block from the library <b>308</b>. In this case, the method also includes the determined number of inputs and outputs of the function node.

[0174] In step <b>426</b> the method traverses the input dependencies of the node to determine which other nodes provide outputs that are provided as inputs to the function node being converted. In step <b>428</b> the method creates a hardware description of an N input AND gate, wherein N is the number of inputs to the node, with each of the N inputs connected to control outputs of nodes which provide inputs to the function node. The output of the AND gate is connected to a control input of the function block corresponding to the function node.

[0175] In the data flow diagramming model of the preferred embodiment, a function node can only execute when all of its inputs have been received. The AND gate created in step <b>428</b> emulates this function by receiving all control outputs of nodes which provide inputs to the function node. Thus the AND gate operates to effectively receive all of the dependent inputs that are connected to the function node and AND them together to provide an output control signal which is determinative of whether the function node has received all of its inputs. The output of the AND gate is connected to the control input of the function block and operates to control execution of the function block. Thus, the function block does not execute until the AND gate output provided to the control input of the function block provides a logic signal indicating that all dependent inputs which are input to the function node have been received.

[0176]FIG. 9—Exporting an Output Terminal into a Hardware Description

[0177]FIG. 9 is a flowchart diagram illustrating operation where the method exports an output terminal into the hardware description. As shown, in step <b>440</b> the method determines if the data provided from the output terminal is output to a portion of the graphical program which will be executing on the CPU, i.e., the portion of the graphical program which is to be compiled into machine language for execution on the CPU, or whether the data is output to another portion of the graphical program that is also being transformed into a hardware implementation.

[0178] As shown, if the data output from the output terminal is determined in step <b>440</b> to be output to a portion of the graphical program being compiled for execution on the CPU, then in step <b>442</b> the method creates a hardware description of a read register with a data input and data and control outputs. The read register is operable to receive data generated by logic representing a prior node in the graphical program.

[0179] In step <b>444</b> the method connects the data output of a prior node to the data input of the read register. In step <b>444</b> the control input of the read register is also connected to control sequencing of execution, i.e., to guarantee that the read register receives data at the proper time. This enables the hardware description to have the same or similar execution order as the graphical program.

[0180] If the data is determined to not be output to a portion being compiled for execution on the CPU step in <b>440</b>, i.e., the data is to another node in the portion being converted into a hardware implementation, then in step <b>446</b> the method ties the data output from the output terminal into a subsequent node in this portion of the hardware description, e.g., ties the data output from the output terminal into the input of subsequent sub-modules as well as control path logic to maintain the semantics of the original graphical program.

[0181]FIG. 10—Exporting a Structure Node into a Hardware Description

[0182]FIG. 10 is a flowchart diagram illustrating operation where the method exports a structure node into the hardware description. In the preferred embodiment, the term “structure node” refers to a node which represents control flow of data, including iteration, looping, sequencing, and conditional branching. Examples of structure nodes include For/Next loops, While/Do loops, Case or Conditional structures, and Sequence structures. For more information on structure nodes, please see the above LabVIEW patents referenced above.

[0183] The flowchart of FIG. 10 illustrates exporting a loop structure node into a hardware description. As shown, in step <b>462</b> the method examines the structure node parameters, e.g., the iteration number, loop condition, period, phase delay, etc. As discussed above, the graphical programming system preferably allows the user to insert certain parameters into a structure node to facilitate exporting the structure node into a hardware description. Iteration and looping structure nodes have previously included an iteration number and loop condition, respectively. According to the preferred embodiment of the invention, these structure nodes further include period and phase delay parameters, which are inserted into or assigned to the structure node. These provide information on the period of execution and the phase delay of the structure node. As discussed below, the period and phase delay parameters, as well as the iteration number or loop condition, are used to facilitate exporting the structure node into a hardware description.

[0184] In step <b>464</b>, the method inserts the structure node parameters into the hardware description. In step <b>466</b> the method inserts a reference to a pre-compiled function block corresponding to the type of structure node. In the case of a looping structure node, the method inserts a reference to a pre-compiled function block which implements the looping function indicated by the structure node. The method also connects controls to the diagram enclosed by the structure node.

[0185]FIG. 11—Converting a Node into a Hardware Description

[0186]FIG. 11 is a flowchart diagram of a portion of step <b>306</b> of FIGS. 4 and 4A, illustrating operation where the method converts the hardware description for a node into a net list. FIG. 11 illustrates operation of converting a hardware description of a node, wherein the hardware description comprises a reference to a function block and may include node parameters. It is noted that where the hardware description of a node comprises a description of the actual registers, gates, etc. which perform the operation of the node, then conversion of this hardware description to a net list is readily performed using any of various types of synthesis tools.

[0187] As shown, in step <b>502</b> the method examines the function block reference and any node parameters present in the hardware description. In step <b>504</b>, the method selects the referenced pre-compiled function block from the library <b>308</b>, which essentially comprises a net list describing the function block. In step <b>506</b> the method then configures the pre-compiled function block net list with any parameters determined in step <b>502</b>. In step <b>508</b> the method then inserts the configured pre-compiled function block into the net list which is being assembled.

[0188]FIG. 12—Converting a Structure Node into a Hardware Description

[0189]FIG. 12 is a flowchart diagram illustrating operation of the flowchart of FIG. 11, where the method converts the hardware description for a structure node into a net list. FIG. 12 illustrates operation of converting a hardware description of a structure node, wherein the hardware description comprises a reference to a structure node function block and includes structure node parameters.

[0190] As shown, in step <b>502</b>A the method examines the function block reference and the structure node parameters present in the hardware description. The structure node parameters may include parameters such as the iteration number, loop condition, period, phase delay, etc. In step <b>504</b>A the method selects the referenced pre-compiled function block from the library <b>308</b>, which essentially is a net list describing the structure node function block. In step <b>506</b>A the method then configures the pre-compiled function block net list with the structure node parameters determined in step <b>502</b>A. This involves setting the period and phase delay of execution of the structure node as well as any other parameters such as iteration number, loop condition, etc. In step <b>508</b>A the method then inserts the configured pre-compiled function block into the net list which is being assembled.

[0191]FIG. 13—Function Block for a Structure Node

[0192]FIG. 13 is a block diagram illustrating a While loop function block. As shown, the While loop function block includes enabling period and phase inputs as well as a loop control input. The While loop function block provides an index output which is provided to and adder. The adder operates to increment each time the index signals provided to monitor the number of times the While loop is executed. The While loop further outputs Clear and Enable Out signals to control the program within the While loop and further receives a Loop Done signal input which is used to indicate whether the loop has completed.

[0193]FIG. 14—Operation of Structure Node Function Block

[0194]FIG. 14 is a state diagram illustrating operation of the while loop function block shown in FIG. 13. As shown, a diagram start operation precedes to state A. When Phase Done is true indicating that the phase has completed, then the state machine advances to state B. The state machine remains in state B until the Loop Enable signal is true, indicating that the loop has been enabled to begin execution. When the Loop Enable signal is asserted, the state machine advances from state B to state C. In state C the Clear Output signal is asserted, clearing the loop output prior to execution of the loop.

[0195] The state machine then advances from state C to state D. In state D the computation is performed, and the Set Enable out signal is asserted. If the period is done and the loop is not yet completed, signified by the equation:

[0196] Period Done and /Loop Done

[0197] then the state machine proceeds to an error state and operation completes. Thus, the period set for execution for the loop was not sufficiently long to allow the loop to complete. In other words, the loop took more time to complete than the period set for execution of the loop.

[0198] The state machine advances from state D to state E when the Loop Done signal is asserted prior to the Period Done signal being asserted, indicating that the loop has completed prior to the period allotted for the loop execution being over.

[0199] The state machine then advances from state E to a wait state, as shown. If the period is done and the loop is not re-enabled, signified by the condition:

[0200] Period Done &amp; /Loop Enabled

[0201] then the state machine advances from the Wait to the Done state. If the period has completed and the loop is still enabled, indicating that another execution of the loop is necessary, then the state machine advances from the Wait state back to the C state. Thus, the state machine advances through state C, D, E, and Wait to perform looping operations.

[0202]FIG. 15—Simple Graphical Program Example

[0203]FIG. 15 illustrates a simple example of a graphical program. In FIG. 15 the graphical program includes three input terminals and one output terminal. The graphical program simply comprises a first 2-input Add function node which receives input from two inputs terminals, and a second 2-input Add function node which receives the output from the first Add function node and receives an output from the third input terminal. The second 2-input Add function node provides an output to output terminal as shown.

[0204]FIG. 16—Hardware Result

[0205]FIG. 16 is a conceptual diagram of the resulting hardware after the graphical program example of FIG. 15 is converted into a hardware description. As shown, the hardware diagram includes three write registers <b>522</b>-<b>526</b> corresponding to each of the three input terminals. The data outputs of the first two write registers <b>522</b> and <b>524</b> are provided as inputs to a first two-input adder <b>532</b>, which corresponds to the first adder in the block diagram of FIG. 15. The hardware description also involves creating an AND gate <b>534</b> which receives control outputs from each of the first two write registers <b>522</b> and <b>524</b> and provides a single output to the control input of the adder <b>532</b>. The purpose of the AND gate <b>534</b> is to prevent the adder <b>532</b> from executing until both inputs have been received.

[0206] The Adder <b>532</b> provides a data output to a second two-input Adder <b>542</b>, which corresponds to the second adder in the block diagram of FIG. 15. The first Adder <b>532</b> also generates an enable out signal which is provided to an input of a second AND gate <b>536</b>. The other input of the AND gate <b>536</b> receives an output from the third write register <b>526</b>, corresponding to the third input terminal. The AND gate <b>536</b> provides an output to a control input of the second adder <b>542</b>. Thus, the AND gate <b>536</b> operates to ensure that the second adder <b>542</b> does not execute until all inputs have been received by the adder <b>542</b>. The second adder <b>542</b> provides a data output to a read register <b>546</b> associated with the output terminal. The second adder <b>542</b> also provides an enable out signal to the read register <b>546</b>, which notifies the read register <b>546</b> when valid data has been provided.

[0207] Thus, as shown, to create a hardware description for each of the input terminals, the flowchart diagram of FIG. 6 is executed, which operates to create a hardware description of a write register <b>522</b>, <b>524</b>, and <b>526</b>, each with data and control outputs. For each adder function node, the flowchart diagram of FIG. 7 is executed, which operates to create a hardware description of an adder <b>532</b> or <b>542</b>, and further creates an associated N input AND gate <b>534</b> or <b>536</b>, with inputs connected to the dependent inputs of the adder function node to ensure execution at the proper time. Finally, the flowchart diagram of FIG. 8 is executed for the output terminal of the graphical program, which operates to generate a hardware description of a read register with data and control inputs.

[0208] FIGS. <b>17</b>-<b>19</b>: Example of Converting a Graphical Program into a Hardware Implementation

[0209] FIGS. <b>17</b>-<b>19</b> comprise a more detailed example illustrating operation of the present invention.

[0210]FIG. 17 illustrates an example graphical program (a LabVIEW diagram) which is converted into an FPGA implementation using the present invention. As shown, the graphical program comprises a plurality of interconnected nodes comprised in a While loop. As shown, the While loop includes shift register icons, represented by the down and up arrows at the left and right edges, respectively, of the While loop. A 0 constant positioned outside of the While loop is connected to the down arrow of the shift register at the left edge of the While loop.

[0211] The While loop includes a timer icon representing or signifying timing for the While loop. The timer icon includes inputs for period and phase. As shown, the timer icon receives a constant of 1000 for the period and receives a constant of 0 for the phase. In an alternate embodiment, the While loop includes input terminals which are configured to receive timing information, such as period and phase.

[0212]FIG. 18 illustrates the LabVIEW data structures created in response to or representing the diagram or graphical program of FIG. 17. The data structure diagram of FIG. 17 comprises a hierarchy of data structures corresponding to the diagram of FIG. 17. As shown, the LabVIEW data structure representation includes a top level diagram which includes a single signal connecting the 0 constant to the left hand shift register of the While loop. Thus the top level diagram includes only the constant (0) and the While loop.

[0213] The While loop includes a sub-diagram which further includes left and right shift register terms, the continue flag of the While loop, a plurality of constants, a timer including period and phase inputs, global variables setpoint and gain, sub-VIs aid read and d/a write, and various function icons, e.g., scale, add, subtract, and multiply. Further, each of the objects in the diagram have terminals, and signals connect between these terminals.

[0214]FIG. 19 illustrates a circuit diagram representing the hardware description which is created in response to the data structures of FIG. 18. The circuit diagram of FIG. 19 implements the graphical program of FIG. 17. As shown, the CPU interface signals are bussed to the global variables. Although not shown in FIG. 19, the CPU interface signals are also provided to the sub-VIs a/d read and d/a write.

[0215] The While loop is essentially abstracted to a control circuit which receives the period and phase, and includes an external enable directing the top level diagram to execute, which starts the loop. The loop then provides a diagram enable(diag_enab) signal to start the loop and waits for a diagram done (diag_done) signal to signify completion of the loop, or the period to expire. Based on the value of the Continue flag, the loop provides a subsequent diag_enab signal or determines that the loop has finished and provides a Done signal to the top level diagram. Although not shown in FIG. 19, the loop control block also provides a diagram clear enable out (diag_clear_enab_out) signal to every node in the sub-diagram of the While loop. Thus the loop control block outputs a diagram enable (diag_enab) signal that is fed to all of the starting nodes in the diagram within the While loop. The Done signals from these items are fed into an AND gate, whose output is provided to enable subsequent nodes.

[0216] The shift register includes a data in, a data out and an enable input which clocks the data in (din) to the data out (dout), and a load which clocks the initial value into the shift register.

[0217] The following is the VHDL description corresponding to the example of FIGS. <b>17</b>-<b>19</b>, wherein the VHDL description was created using the present invention: <tables id="TABLE-US-00001" num="1"><table frame="none" colsep="0" rowsep="0" pgwide="1"><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="245PT" align="left" /><thead><row>&lt;entry /&gt;&lt;entry /&gt;</row><row>&lt;entry /&gt;<entry namest="OFFSET" nameend="1" align="center" rowsep="1" /></row></thead><tbody valign="top"><row>&lt;entry /&gt;<entry>library ieee;</entry></row><row>&lt;entry /&gt;<entry>use ieee.std_logic_1164.all;</entry></row><row>&lt;entry /&gt;<entry>entity example0 is</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>port (</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>clk : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>enable_in : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>clr_enable_out : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>da_clk : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>cpu_clk : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>cpu_reset : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>cpu_iord : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>cpu_iowt : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>cpu_devsel : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>cpu_ioaddr : in std_logic_vector(31 downto 0);</entry></row><row>&lt;entry /&gt;<entry>cpu_iodata : in std_logic_vector(31 downto 0);</entry></row><row>&lt;entry /&gt;<entry>ad_clk : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>enable_out : out std_logic</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="245PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>end example0;</entry></row><row>&lt;entry /&gt;<entry>architecture Structural of example0 is</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>signal sCLK : std_logic;</entry></row><row>&lt;entry /&gt;<entry>signal sda_clk : std_logic;</entry></row><row>&lt;entry /&gt;<entry>signal scpu_clk : std_logic;</entry></row><row>&lt;entry /&gt;<entry>signal scpu_reset : std_logic;</entry></row><row>&lt;entry /&gt;<entry>signal scpu_iord : std_logic;</entry></row><row>&lt;entry /&gt;<entry>signal scpu_iowt : std_logic;</entry></row><row>&lt;entry /&gt;<entry>signal scpu_devsel : std_logic;</entry></row><row>&lt;entry /&gt;<entry>signal scpu_ioaddr : std_logic_vector(31 downto 0);</entry></row><row>&lt;entry /&gt;<entry>signal scpu_iodata : std_logic_vector(31 downto 0);</entry></row><row>&lt;entry /&gt;<entry>signal sad_clk : std_logic;</entry></row><row>&lt;entry /&gt;<entry>signal s1AC : std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>signal s115 : std_logic; -- node 114 enable_out</entry></row><row>&lt;entry /&gt;<entry>constant cE8C : std_logic_vector(15 downto 0) := “0000000000000000”; -</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="1"><colspec colname="1" colwidth="259PT" align="left" /><tbody valign="top"><row><entry>- 0</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>signal s114 : std_logic; -- diagram done</entry></row><row>&lt;entry /&gt;<entry>signal s116 : std_logic; -- diagram clr_enable_out</entry></row><row>&lt;entry /&gt;<entry>signal s278D : std_logic; -- node 278C enable_out</entry></row><row>&lt;entry /&gt;<entry>signal s145 : std_logic; -- node 144 enable_out</entry></row><row>&lt;entry /&gt;<entry>component shift16</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>port (</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>clk : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>enable_in, load : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>initval : in std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>din : in std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>dout : out std_logic_vector(15 downto 0)</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>end component;</entry></row><row>&lt;entry /&gt;<entry>signal s1310 : std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>signal s209C : std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>signal s1344 : std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>signal s1628 : std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>signal s1270 : std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>signal s1684 : std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>signal s19CC : std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>signal s1504 : std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>signal s149C : std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>signal sC44 : std_logic_vector(31 downto 0);</entry></row><row>&lt;entry /&gt;<entry>signal s974 : std_logic_vector(31 downto 0);</entry></row><row>&lt;entry /&gt;<entry>signal s4D8 : std_logic;</entry></row><row>&lt;entry /&gt;<entry>signal s2A1 : std_logic; -- node 2A0 enable_out</entry></row><row>&lt;entry /&gt;<entry>constant c470 : std_logic := ‘1’;</entry></row><row>&lt;entry /&gt;<entry>constant c948 : std_logic_vector(31 downto 0) :=</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="1"><colspec colname="1" colwidth="259PT" align="left" /><tbody valign="top"><row><entry>“00000000000000000000001111101000”; -- 1000</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>constant cC04 : std_logic_vector(31 downto 0) :=</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="1"><colspec colname="1" colwidth="259PT" align="left" /><tbody valign="top"><row><entry>“00000000000000000000000000000000”; -- 0</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>constant c1960 : std_logic_vector(15 downto 0) := “1111111111111111”;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="1"><colspec colname="1" colwidth="259PT" align="left" /><tbody valign="top"><row><entry>-- -1</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>signal s2A0 : std_logic; -- diagram done</entry></row><row>&lt;entry /&gt;<entry>signal s2A2 : std_logic; -- diagram clr_enable_out</entry></row><row>&lt;entry /&gt;<entry>component write_reg</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>port (</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>clk : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>enable_in : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>clr_enable_out : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>cpu_clk : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>cpu_reset : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>cpu_iord : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>cpu_iowt : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>cpu_devsel : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>cpu_ioaddr : in std_logic_vector(31 downto 0);</entry></row><row>&lt;entry /&gt;<entry>cpu_iodata : in std_logic_vector(31 downto 0);</entry></row><row>&lt;entry /&gt;<entry>decodeaddr : in std_logic_vector(3 downto 0);</entry></row><row>&lt;entry /&gt;<entry>data : out std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>enable_out : out std_logic</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>end component;</entry></row><row>&lt;entry /&gt;<entry>signal s5BA : std_logic_vector(3 downto 0);</entry></row><row>&lt;entry /&gt;<entry>constant c5B8 : std_logic_vector(3 downto 0) := “00”;</entry></row><row>&lt;entry /&gt;<entry>signal s1A7E : std_logic_vector(3 downto 0);</entry></row><row>&lt;entry /&gt;<entry>constant c1A7C : std_logic_vector(3 downto 0) := “10”;</entry></row><row>&lt;entry /&gt;<entry>signal s641 : std_logic; -- node 640 enable_out</entry></row><row>&lt;entry /&gt;<entry>signal s39D : std_logic; -- node 39C enable_out</entry></row><row>&lt;entry /&gt;<entry>component a_d_read</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>port (</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>clk : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>enable_in, clr_enable_out : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>ai_read_val : out std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>ad_clk : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>enable_out : out std_logic</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>end component;</entry></row><row>&lt;entry /&gt;<entry>signal s13A1 : std_logic; -- node 13A0 enable_out</entry></row><row>&lt;entry /&gt;<entry>component prim_Scale_By_Power_Of_2_16</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>port (</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>clk : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>enable_in, clr_enable_out : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>x_2_n : out std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>x : in std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>n : in std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>enable_out : out std_logic</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>end component;</entry></row><row>&lt;entry /&gt;<entry>signal s10E9 : std_logic; -- node 10E8 enable_out</entry></row><row>&lt;entry /&gt;<entry>component prim_Subtract_16</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>port (</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>clk : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>enable_in, clr_enable_out : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>x_y : out std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>y : in std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>x : in std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>enable_out : out std_logic</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>end component;</entry></row><row>&lt;entry /&gt;<entry>signal s14D1 : std_logic; -- node 14D0 enable_out</entry></row><row>&lt;entry /&gt;<entry>component prim_Add_16</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>port (</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>clk : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>enable_in, clr_enable_out : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>x_y : out std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>y : in std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>x : in std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>enable_out : out std_logic</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>end component;</entry></row><row>&lt;entry /&gt;<entry>signal s1A01 : std_logic; -- node 1A00 enable_out</entry></row><row>&lt;entry /&gt;<entry>component prim_Multiply_16</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>port (</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>clk : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>enable_in, clr_enable_out : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>x_y : out std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>y : in std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>x : in std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>enable_out : out std_logic</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>end component;</entry></row><row>&lt;entry /&gt;<entry>signal s1725 : std_logic; -- node 1724 enable_out</entry></row><row>&lt;entry /&gt;<entry>component d_a_write</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>port (</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>clk : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>enable_in, clr_enable_out : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>a0_write_val : in std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>da_clk : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>enable_out : out std_logic</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>end component;</entry></row><row>&lt;entry /&gt;<entry>component whileloop_timed</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>port (</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>clk : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>enable_in, clr_enable_out : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>diag_enable, diag_clr_enable_out : out std_logic;</entry></row><row>&lt;entry /&gt;<entry>diag_done : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>period : in std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>phase : in std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>continue : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>enable_out : out std_logic</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>end component;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="245PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>begin</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>s114 &lt;= s278D AND s145;</entry></row><row>&lt;entry /&gt;<entry>s1AC &lt;= cE8C;</entry></row><row>&lt;entry /&gt;<entry>nDF8: shift16</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>port map(</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>clk =&gt; sCLK,</entry></row><row>&lt;entry /&gt;<entry>load =&gt; s115,</entry></row><row>&lt;entry /&gt;<entry>enable_in =&gt; s2A0,</entry></row><row>&lt;entry /&gt;<entry>initval =&gt; s1AC,</entry></row><row>&lt;entry /&gt;<entry>din =&gt; s1344,</entry></row><row>&lt;entry /&gt;<entry>dout =&gt; s19CC</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>s2A0 &lt;= s1725;</entry></row><row>&lt;entry /&gt;<entry>s4D8 &lt;= c470;</entry></row><row>&lt;entry /&gt;<entry>s974 &lt;= c948;</entry></row><row>&lt;entry /&gt;<entry>sC44 &lt;= cC04;</entry></row><row>&lt;entry /&gt;<entry>s1684 &lt;= c1960;</entry></row><row>&lt;entry /&gt;<entry>-- setpoint</entry></row><row>&lt;entry /&gt;<entry>n5B8: write_reg</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>port map(</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>clk =&gt; sCLK,</entry></row><row>&lt;entry /&gt;<entry>enable_in =&gt; s2A1,</entry></row><row>&lt;entry /&gt;<entry>clr_enable_out =&gt; s2A2,</entry></row><row>&lt;entry /&gt;<entry>enable_out =&gt; s5B9,</entry></row><row>&lt;entry /&gt;<entry>cpu_clk =&gt; scpu_clk,</entry></row><row>&lt;entry /&gt;<entry>cpu_reset =&gt; scpu_reset,</entry></row><row>&lt;entry /&gt;<entry>cpu_iord =&gt; scpu_iord,</entry></row><row>&lt;entry /&gt;<entry>cpu_iowt =&gt; scpu_iowt,</entry></row><row>&lt;entry /&gt;<entry>cpu_devsel =&gt; scpu_devsel,</entry></row><row>&lt;entry /&gt;<entry>cpu_ioaddr =&gt; scpu_ioaddr,</entry></row><row>&lt;entry /&gt;<entry>cpu_iodata =&gt; scpu_iodata,</entry></row><row>&lt;entry /&gt;<entry>decodeaddr =&gt; s5BA,</entry></row><row>&lt;entry /&gt;<entry>data =&gt; s149C</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>s5BA &lt;= c5B8;</entry></row><row>&lt;entry /&gt;<entry>-- gain</entry></row><row>&lt;entry /&gt;<entry>n1A7C: write_reg</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>port map(</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>clk =&gt; sCLK,</entry></row><row>&lt;entry /&gt;<entry>enable_in =&gt; s2A1,</entry></row><row>&lt;entry /&gt;<entry>clr_enable_out =&gt; s2A2,</entry></row><row>&lt;entry /&gt;<entry>enable_out =&gt; s1A7D,</entry></row><row>&lt;entry /&gt;<entry>cpu_clk =&gt; scpu_clk,</entry></row><row>&lt;entry /&gt;<entry>cpu_reset =&gt; scpu_reset,</entry></row><row>&lt;entry /&gt;<entry>cpu_iord =&gt; scpu_iord,</entry></row><row>&lt;entry /&gt;<entry>cpu_iowt =&gt; scpu_iowt,</entry></row><row>&lt;entry /&gt;<entry>cpu_devsel =&gt; scpu_devsel,</entry></row><row>&lt;entry /&gt;<entry>cpu_ioaddr =&gt; scpu_ioaddr,</entry></row><row>&lt;entry /&gt;<entry>cpu_iodata =&gt; scpu_iodata,</entry></row><row>&lt;entry /&gt;<entry>decodeaddr =&gt; s1A7E,</entry></row><row>&lt;entry /&gt;<entry>data =&gt; s1628</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>s1A7E &lt;= c1A7C;</entry></row><row>&lt;entry /&gt;<entry>n39C: a_d_read</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>port map(</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>clk =&gt; sCLK,</entry></row><row>&lt;entry /&gt;<entry>enable_in =&gt; s2A1,</entry></row><row>&lt;entry /&gt;<entry>clr_enable_out =&gt; s2A2,</entry></row><row>&lt;entry /&gt;<entry>ai_read_val =&gt; s1504,</entry></row><row>&lt;entry /&gt;<entry>ad_clk =&gt; sad_clk,</entry></row><row>&lt;entry /&gt;<entry>enable_out =&gt; s39D</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>n13A0: prim_Scale_By_Power_Of_2_16</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>port map(</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>clk =&gt; sCLK,</entry></row><row>&lt;entry /&gt;<entry>enable_in =&gt; s2A1,</entry></row><row>&lt;entry /&gt;<entry>clr_enable_out =&gt; s2A2,</entry></row><row>&lt;entry /&gt;<entry>x_2_n =&gt; s1270,</entry></row><row>&lt;entry /&gt;<entry>x =&gt; s19CC,</entry></row><row>&lt;entry /&gt;<entry>n =&gt; s1684,</entry></row><row>&lt;entry /&gt;<entry>enable_out =&gt; s13A1</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>s10E8 &lt;= s39D AND s5B9;</entry></row><row>&lt;entry /&gt;<entry>n10E8: prim_Subtract_16</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>port map(</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>clk =&gt; sCLK,</entry></row><row>&lt;entry /&gt;<entry>enable_in =&gt; s10E8,</entry></row><row>&lt;entry /&gt;<entry>clr_enable_out =&gt; s2A2,</entry></row><row>&lt;entry /&gt;<entry>x_y =&gt; s1310,</entry></row><row>&lt;entry /&gt;<entry>y =&gt; s1504,</entry></row><row>&lt;entry /&gt;<entry>x =&gt; s149C,</entry></row><row>&lt;entry /&gt;<entry>enable_out =&gt; s10E9</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>s14D0 &lt;= s13A1 AND s10E9;</entry></row><row>&lt;entry /&gt;<entry>n14D0: prim_Add_16</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>port map(</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>clk =&gt; sCLK,</entry></row><row>&lt;entry /&gt;<entry>enable_in =&gt; s14D0,</entry></row><row>&lt;entry /&gt;<entry>clr_enable_out =&gt; s2A2,</entry></row><row>&lt;entry /&gt;<entry>x_y =&gt; s1344,</entry></row><row>&lt;entry /&gt;<entry>y =&gt; s1270,</entry></row><row>&lt;entry /&gt;<entry>x =&gt; s1310,</entry></row><row>&lt;entry /&gt;<entry>enable_out =&gt; s14D1</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>s1A00 &lt;= s14D1 AND s1A7D;</entry></row><row>&lt;entry /&gt;<entry>n1A00: prim_Multiply_16</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>port map(</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>clk =&gt; sCLK,</entry></row><row>&lt;entry /&gt;<entry>enable_in =&gt; s1A00,</entry></row><row>&lt;entry /&gt;<entry>clr_enable_out =&gt; s2A2,</entry></row><row>&lt;entry /&gt;<entry>x_y =&gt; s209C,</entry></row><row>&lt;entry /&gt;<entry>y =&gt; s1344,</entry></row><row>&lt;entry /&gt;<entry>x =&gt; s1628,</entry></row><row>&lt;entry /&gt;<entry>enable_out =&gt; s1A01</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>n1724: d_a_write</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>port map(</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>clk =&gt; SCLK,</entry></row><row>&lt;entry /&gt;<entry>enable_in =&gt; s1A01,</entry></row><row>&lt;entry /&gt;<entry>clr_enable_out =&gt; s2A2,</entry></row><row>&lt;entry /&gt;<entry>a0_write_val =&gt; s209C,</entry></row><row>&lt;entry /&gt;<entry>da_clk =&gt; sda_clk,</entry></row><row>&lt;entry /&gt;<entry>enable_out =&gt; s1725</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>n144: whileloop_timed</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>port map(</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>clk =&gt; sCLK,</entry></row><row>&lt;entry /&gt;<entry>enable_in =&gt; s115,</entry></row><row>&lt;entry /&gt;<entry>clr_enable_out =&gt; s116,</entry></row><row>&lt;entry /&gt;<entry>period =&gt; sC44,</entry></row><row>&lt;entry /&gt;<entry>phase =&gt; s974,</entry></row><row>&lt;entry /&gt;<entry>diag_enable =&gt; s2A1,</entry></row><row>&lt;entry /&gt;<entry>diag_clr_enable_out =&gt; s2A2,</entry></row><row>&lt;entry /&gt;<entry>diag_done =&gt; s2A0,</entry></row><row>&lt;entry /&gt;<entry>continue =&gt; s4D8,</entry></row><row>&lt;entry /&gt;<entry>enable_out =&gt; s145</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="231PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>sCLK &lt;= clk;</entry></row><row>&lt;entry /&gt;<entry>s115 &lt;= enable_in;</entry></row><row>&lt;entry /&gt;<entry>s116 &lt;= clr_enable_out;</entry></row><row>&lt;entry /&gt;<entry>s114 &lt;= enable_out;</entry></row><row>&lt;entry /&gt;<entry>sda_clk &lt;= da_clk;</entry></row><row>&lt;entry /&gt;<entry>scpu_clk &lt;= cpu_clk;</entry></row><row>&lt;entry /&gt;<entry>scpu_reset &lt;= cpu_reset;</entry></row><row>&lt;entry /&gt;<entry>scpu_iord &lt;= cpu_iord;</entry></row><row>&lt;entry /&gt;<entry>scpu_iowt &lt;= cpu_iowt;</entry></row><row>&lt;entry /&gt;<entry>scpu_devsel &lt;= cpu_devsel;</entry></row><row>&lt;entry /&gt;<entry>scpu_ioaddr &lt;= cpu_ioaddr;</entry></row><row>&lt;entry /&gt;<entry>scpu_iodata &lt;= cpu_iodata;</entry></row><row>&lt;entry /&gt;<entry>sad_clk &lt;= ad_clk;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="245PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>end Structural;</entry></row><row>&lt;entry /&gt;<entry namest="OFFSET" nameend="1" align="center" rowsep="1" /></row></tbody></tgroup></table></tables>

[0218] Component Library

[0219] The preferred embodiment of the present invention includes a component library that is used to aid in converting various primitives or nodes in a graphical program into a hardware description, such as a VHDL source file. The following provides two examples of VHDL components in this component library, these being components for a While loop and a multiplier primitive.

[0220] 1. While Loop Component

[0221] The following comprises a VHDL component referred to as whileloop.vhd that the present invention uses when a While loop appears on a graphical program or diagram. Whileloop.vhd shows how a While loop in a graphical program is mapped to a state machine in hardware. It is noted that other control structures such as a “For loop” are similar. Whileloop.vhd is as follows: <tables id="TABLE-US-00002" num="2"><table frame="none" colsep="0" rowsep="0"><tgroup align="left" colsep="0" rowsep="0" cols="1"><colspec colname="1" colwidth="217PT" align="left" /><thead><row>&lt;entry /&gt;</row><row><entry namest="1" nameend="1" align="center" rowsep="1" /></row></thead><tbody valign="top"><row><entry>library ieee;</entry></row><row><entry>use ieee.std_logic_1164.all;</entry></row><row><entry>entity whileloop is</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>port(</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="189PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>clk,</entry></row><row>&lt;entry /&gt;<entry>enable_in,  -- start loop execution</entry></row><row>&lt;entry /&gt;<entry>clr_enable_out  -- reset loop execution</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="175PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>: in std_logic;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="189PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>diag_enable,  -- start contained diagram execution</entry></row><row>&lt;entry /&gt;<entry>diag_clr_enable_out -- reset contained diagram execution</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="175PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>: out std_logic;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="189PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>diag done,  -- contained diagram finished</entry></row><row>&lt;entry /&gt;<entry>continue  -- iteration enabled</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="175PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>: in std_logic;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="189PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>enable_out  -- looping complete</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="175PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>: out std_logic</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="1"><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row><entry>end whileloop;</entry></row><row><entry>architecture rtl of whileloop is</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>type state_t is (idle_st, -- reset state</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="70PT" align="left" /><colspec colname="1" colwidth="147PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>test_st, -- check for loop completion</entry></row><row>&lt;entry /&gt;<entry>calc_st, -- enable diagram execution</entry></row><row>&lt;entry /&gt;<entry>end_st -- assert enable_out</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="161PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>signal nstate,state : state_t;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="1"><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row><entry>begin</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>process(state,enable_in,clr_enable_out,diag_done,continue)</entry></row><row>&lt;entry /&gt;<entry>begin</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="189PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>diag_clr_enable_out &lt;= ‘0’;</entry></row><row>&lt;entry /&gt;<entry>diag_enable &lt;= ‘0’;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>enable_out &lt;= ‘0’;</entry></row><row>&lt;entry /&gt;<entry>case state is</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="189PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>when idle_st =&gt;</entry></row><row>&lt;entry /&gt;<entry>diag_clr_enable_out &lt;= ‘1’;</entry></row><row>&lt;entry /&gt;<entry>if enable_in=‘1’ then</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="161PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>nstate &lt;= test_st;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="175PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>else</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="161PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>nstate &lt;= idle_st;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="175PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>end if;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="189PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>when test_st =&gt;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="175PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>diag_clr_enable_out &lt;= ‘1’;</entry></row><row>&lt;entry /&gt;<entry>if continue=‘1’ then</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="161PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>nstate &lt;= calc_st;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="175PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>else</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="161PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>nstate &lt;= end_st;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="175PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>end if;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="189PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>when calc_st =&gt;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="175PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>diag_enable &lt;= ‘1’;</entry></row><row>&lt;entry /&gt;<entry>if diag_done=‘1’ then</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="161PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>nstate &lt;= test_st;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="175PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>else</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="161PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>nstate &lt;= calc_st;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="175PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>end if;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="189PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>when end_st =&gt;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="175PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>enable__out &lt;= ‘1’;</entry></row><row>&lt;entry /&gt;<entry>nstate &lt;= end_st;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>end case;</entry></row><row>&lt;entry /&gt;<entry>-- Because it appears at the end of the process, this test</entry></row><row>&lt;entry /&gt;<entry>-- overrides any previous assignments to nstate</entry></row><row>&lt;entry /&gt;<entry>if clr_enable_out=‘1’ then</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="189PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>nstate &lt;= idle_st;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>end if;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="1"><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row><entry>end process;</entry></row><row><entry>process(clk)</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>begin</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="189PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>if clk‘event and clk=‘1’ then</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="175PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>state &lt;= nstate;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="189PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>end if;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="203PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>end process;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="1"><colspec colname="1" colwidth="217PT" align="left" /><tbody valign="top"><row><entry>end rtl;</entry></row><row><entry namest="1" nameend="1" align="center" rowsep="1" /></row></tbody></tgroup></table></tables>

[0222] 2. Multiplier Primitive Component

[0223] The following comprises a VHDL component referred to as prim_multiply_—16.vhd that the present invention uses when a multiplier primitive appears on a graphical program or diagram. By following the path from enable_in to enable_out, it can be seen how the self-timed logic works—each component asserts enable_out when the data output is valid. Other primitives like “add” or “less than” operate in a similar manner. Prim_multiply_—16.vhd is as follows: <tables id="TABLE-US-00003" num="3"><table frame="none" colsep="0" rowsep="0" pgwide="1"><tgroup align="left" colsep="0" rowsep="0" cols="1"><colspec colname="1" colwidth="294PT" align="left" /><thead><row>&lt;entry /&gt;</row><row><entry namest="1" nameend="1" align="center" rowsep="1" /></row></thead><tbody valign="top"><row><entry>library ieee;</entry></row><row><entry>use ieee.std_logic_1164.all;</entry></row><row><entry>entity prim_multiply_16 is</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="280PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>port(</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="266PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>clk : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>enable_in : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>clr_enable_out : in std_logic;</entry></row><row>&lt;entry /&gt;<entry>x_y : out std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>x : in std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>y : in std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>enable_out : out std_logic</entry></row><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="280PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>end prim_multiply_16;</entry></row><row>&lt;entry /&gt;<entry>architecture altera of prim_multiply_16 is</entry></row><row>&lt;entry /&gt;<entry>COMPONENT lpm_mult</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="266PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>GENERIC (LPM_WIDTHA: POSITIVE;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="252PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>LPM_WIDTHB: POSITIVE;</entry></row><row>&lt;entry /&gt;<entry>LPM_WIDTHS: POSITIVE;</entry></row><row>&lt;entry /&gt;<entry>LPM_WIDTHP: POSITIVE;</entry></row><row>&lt;entry /&gt;<entry>LPM_REPRESENTATION: STRING := “UNSIGNED”;</entry></row><row>&lt;entry /&gt;<entry>LPM_PIPELINE: INTEGER := 0;</entry></row><row>&lt;entry /&gt;<entry>LPM_TYPE: STRING := “L_MULT”</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="266PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="280PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>PORT (dataa: IN STD_LOGIC_VECTOR(LPM_WIDTHA-1 DOWNTO 0);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="252PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>datab: IN STD_LOGIC_VECTOR(LPM_WIDTHB-1 DOWNTO 0);</entry></row><row>&lt;entry /&gt;<entry>aclr: IN STD_LOGIC := ‘0’;</entry></row><row>&lt;entry /&gt;<entry>clock: IN STD_LOGIC := ‘0’;</entry></row><row>&lt;entry /&gt;<entry>sum: IN STD_LOGIC_VECTOR(LPM_WIDTHS-1 DOWNTO 0) := (OTHERS =&gt;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="1"><colspec colname="1" colwidth="294PT" align="left" /><tbody valign="top"><row><entry>‘0’);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="252PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>result : OUT STD_LOGIC_VECTOR(LPM_WIDTHP-1 DOWNTO 0));</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="1"><colspec colname="1" colwidth="294PT" align="left" /><tbody valign="top"><row><entry>END COMPONENT;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="280PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>signal 1_x,1_y : std_logic_vector(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>signal 1_xy : std_logic_vector(31 downto 0);</entry></row><row>&lt;entry /&gt;<entry>signal 1_enable_in : std_logic;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="1"><colspec colname="1" colwidth="294PT" align="left" /><tbody valign="top"><row><entry>begin</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="280PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>-- synchronize the incoming and outgoing data to guarantee</entry></row><row>&lt;entry /&gt;<entry>-- a registered path on data through the multiplier</entry></row><row>&lt;entry /&gt;<entry>-- register enable_out so it won't assert before data is</entry></row><row>&lt;entry /&gt;<entry>-- available.</entry></row><row>&lt;entry /&gt;<entry>process(clk)</entry></row><row>&lt;entry /&gt;<entry>begin</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="266PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>if clk′event and clk=‘1’ then</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="252PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>if clr_enable_out=‘1’ then</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="238PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>enable_out &lt;=‘0’;</entry></row><row>&lt;entry /&gt;<entry>1_enable_in &lt;= ‘0’;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="252PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>else</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="238PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>enable_out &lt;= 1_enable_in;</entry></row><row>&lt;entry /&gt;<entry>1_enable_in &lt;= enable_in;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="252PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>end if;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="266PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>1_x &lt;= x;</entry></row><row>&lt;entry /&gt;<entry>1_y &lt;= y;</entry></row><row>&lt;entry /&gt;<entry>x_y &lt;= 1_xy(15 downto 0);</entry></row><row>&lt;entry /&gt;<entry>end if;</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="280PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>end process;</entry></row><row>&lt;entry /&gt;<entry>gainx: lpm_mult</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="252PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>GENERIC map(</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="238PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>LPM_WIDTHA =&gt; 16,</entry></row><row>&lt;entry /&gt;<entry>LPM_WIDTHB =&gt; 16,</entry></row><row>&lt;entry /&gt;<entry>LPM_WIDTHS =&gt; 1,</entry></row><row>&lt;entry /&gt;<entry>LPM_WIDTHP =&gt; 32,</entry></row><row>&lt;entry /&gt;<entry>LPM_REPRESENTATION =&gt; “UNSIGNED”,</entry></row><row>&lt;entry /&gt;<entry>LPM_PIPELINE =&gt; 0</entry></row><row>&lt;entry /&gt;<entry>)</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="252PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>PORT map(</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="238PT" align="left" /><tbody valign="top"><row>&lt;entry /&gt;<entry>dataa =&gt; 1_x,</entry></row><row>&lt;entry /&gt;<entry>datab =&gt; 1_y,</entry></row><row>&lt;entry /&gt;<entry>result =&gt; 1_xy</entry></row><row>&lt;entry /&gt;<entry>);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="1"><colspec colname="1" colwidth="294PT" align="left" /><tbody valign="top"><row><entry>end altera;</entry></row><row><entry namest="1" nameend="1" align="center" rowsep="1" /></row></tbody></tgroup></table></tables>

[0224] Although the system and method of the present invention has been described in connection with the preferred embodiment, it is not intended to be limited to the specific form set forth herein, but on the contrary, it is intended to cover such alternatives, modifications, and equivalents, as can be reasonably included within the spirit and scope of the invention as defined by the appended claims.