Virtual machine programming system

This is a continuation of application Ser. No. 07/238,145 filed Aug. 30, 1988, and now abandoned, which is a divisional application of Ser. No. 06/798,931 filed Nov. 18, 1985, now U.S. Pat. No. 4,849,880 issued Jul. 18, 1989.

BACKGROUND OF THE INVENTION

The present invention relates in general to programming of computer systems and more particularly to a method and apparatus for developing applications software.

The number of applications for computers has grown remarkably in the last few years and so too has the number of persons skilled in the art of computer programming. Nonetheless computer literacy is not universal and in any case the programming of any new system is usually time consuming. One category of a programmable system involves computer controlled combinations of test instruments adapted to provide a common result. Microcomputers have been incorporated into the design of many electronic test instruments such as multimeters, signal generators, logic analyzers, digitizers and the like wherein the microcomputers typically control instrument settings, data storage and display, and often provide communication with a host computer through interconnecting buses. The host computer may be programmed to supply instructions to the microprocessor in each instrument for controlling the operation of the individual instruments in performing selected tests, while also acquiring data from the instruments, performing calculations based on the acquired data, and displaying the results. Once computer software is developed for various tests to be performed the computer-based instrument system greatly reduces the labor required inasmuch as an operator does not then have to manually adjust the settings of the instruments before or during such test and does not have to manually assemble or process the data acquired. However, the major drawback to such computer-based instrument systems relates to the need for development of separate host computer software for each combination of tests. Testing is described by way of example and it is understood the problems associated with assembling of other combination systems may be similarly addressed. What is needed is a method and apparatus for permitting persons not skilled in the art of computer programming to easily develop easily used computer applications software.

SUMMARY OF THE INVENTION

According to one aspect of the present invention, a computer programming system provides a set of software-based “virtual machines” each for receiving input parameters and for producing output parameters related to the input data in a selected manner. Each virtual machine is suitably represented by a corresponding “virtual front panel” comprising a graphical display or other means for representing its input and output data. The system permits an operator to adjust the values of input parameters displayed by the virtual front panel, by manipulating a cursor or the like, and allows the operator to command the machine to “run” (i.e., to produce and display its output parameters based on the current input parameters) by selecting a command from a displayed menu or other input. The virtual machine front panel provides a graphical representation of underlying virtual machine software in a manner easily understood by an operator and facilitates communication between software and operator.

According to another aspect of the present invention, the operator can define a “synthesized virtual machine” for performing a selected sequence of operations, the operator defining each operation of the sequence by selecting a pre-existing virtual machine capable of performing such operation. The operator also names the input and output parameters of the virtual machine and specifies where the input parameters required by each operation of the sequence are to be obtained. The programming system of the present invention then generates and stores computer code necessary to implement the synthesized virtual machine, including an associated virtual front panel according to the operator's specification, thereby permitting an operator to create applications software without actually writing it. Once the software for a virtual machine has been synthesized, the operator may create instances and for each may adjust the input parameters of the synthesized virtual machine and command it to run in the same manner as any other virtual machine.

According to a further aspect of the invention, the operator may synthesize additional “higher order” virtual machines wherein one or more of a sequence of operations is carried out by previously synthesized virtual machines. In such fashion the operator may create a hierarchy of synthesized virtual machines, each higher order virtual machine employing lower order machines in performing its function. This aspect of the invention permits an operator to create highly complex applications software in a structured manner wherein each separate element of the software comprises a virtual machine which can be independently tested and modified, thereby simplifying the process of developing and debugging applications software.

According to still another aspect of the invention in a preferred embodiment thereof, a host computer is connected through a bus to a set of microcomputer-based instruments such as voltmeters, signal generators and the like, each adapted for performing a selected test or other function. Each instrument is represented by the host computer as a corresponding virtual “instrument” or machine including means to transmit input parameters to the corresponding instrument and to receive output parameters therefrom, the input and output parameters being displayed on a corresponding virtual front panel. Selected host computer operations such as addition, multiplication, and the like, are also carried out by representative virtual machines. Each virtual machine is available for selection by an operator when synthesizing a higher level virtual machine so that operation of any real instrument may form a step in a sequence of operations performed by the higher level virtual machine.

Accordingly, an operator may synthesize a virtual machine to control and coordinate the operations of one or more instruments accessed by the host computer, perform computations based on the data produced by such instruments, and display the results of the computations as outputs on a virtual front panel.

It is therefore an object of the invention to provide a new and improved method and apparatus for organizing computer operation.

It is another object of the invention to provide a new and improved method and apparatus for developing and structuring computer applications software.

It is a further object of the invention to provide a new and improved method and apparatus for programming a computer-based instrument system.

The subject matter of the present invention is particularly pointed out and distinctly claimed in the concluding portion of this specification. However, both the organization and method of operation of the present invention, together with further advantages and objects thereof, may best be understood by reference to the following description taken in connection with accompanying drawings wherein like reference characters refer to like elements.

DRAWINGS

<figref idref="DRAWINGS">FIG. 1</figref> is a block diagram of a computer-based instrument system for implementing the present invention;

<figref idref="DRAWINGS">FIGS. 2A-2F</figref> are views of virtual front panels for selected virtual instruments;

<figref idref="DRAWINGS">FIGS. 3A-3P</figref> comprise menus, lists and dialog box displays produced by the present invention;

<figref idref="DRAWINGS">FIG. 4</figref> illustrates an example of a synthesizing window display according to the present invention; and

<figref idref="DRAWINGS">FIGS. 5-8</figref> are charts of code listings for implementing the present invention.

DETAILED DESCRIPTION

Referring to <figref idref="DRAWINGS">FIG. 1</figref>, there is depicted in block diagram form a computer-based instrument system <b>10</b> adapted to control and coordinate the operations of a plurality of computer-based instruments <b>12</b> according to the present invention. Instruments <b>12</b> include, by way of example, a signal generator <b>14</b>, a voltmeter <b>16</b>, and such other instruments <b>18</b> as may be useful for testing a device under test <b>20</b>. Each instrument <b>12</b> includes means for receiving signals and input data for controlling its operation from a host computer <b>22</b> transmitted over a means for communication such as a bus <b>24</b> and/or means to transmit acquired data back to the host computer <b>22</b> over means <b>24</b>. The system <b>10</b> also includes a terminal <b>26</b> having a display screen and input devices including a keyboard and a mouse controller or similar device for controlling the position of a cursor on the screen. The mouse is provided with three buttons: a red button for selecting objects indicated by the cursor, a blue button for opening a menu for controlling the display of a selected display window on the screen, and a yellow button for opening menus for controlling the behavior of software associated with a selected window.

According to the present invention, the host computer <b>22</b> is adapted to communicate with each instrument <b>12</b> by means of a corresponding software-based virtual instrument (i.e., virtual machine) comprising a set of computer instructions for performing a selected function and which may be graphically represented in the form of a corresponding “virtual front panel” displayed on terminal <b>26</b>. The virtual front panel associated with a virtual machine suitably displays the values of any input parameters used by the machine and any output parameters produced by the virtual machine.

A virtual instrument or machine may be adapted to transmit its input parameters to the corresponding real instrument and to acquire its output parameters from the real instrument through bus <b>24</b>.

Signal generator <b>14</b> suitably produces a sinewave signal having two variables, frequency and amplitude, as controlled by data provided by the host computer <b>12</b> via bus <b>24</b>. Referring to <figref idref="DRAWINGS">FIG. 2A</figref>, there is depicted a virtual front panel <b>28</b> of a virtual instrument associated with signal generator <b>14</b>. The values of the frequency and amplitude control variables, comprising input parameters of the virtual instrument, are graphically displayed on the screen of terminal <b>26</b> in the form of two simulated, dial-type, logarithmic scale meters <b>30</b> and <b>32</b>. As indicated the signal generator <b>14</b> has a frequency range of 1 to 10 (e.g. Hertz) and an amplitude range of 1 to 10 (e.g. volts). The meter representations in the <figref idref="DRAWINGS">FIG. 2A</figref> display are illustrative of settings of 1.0 Hertz and 1.0 volts. The value indicated by each analog meter is also digitally displayed in the center of the meter.

Referring to <figref idref="DRAWINGS">FIG. 2B</figref>, there is depicted a virtual front panel <b>34</b> of a virtual instrument associated with the voltmeter <b>16</b> of <figref idref="DRAWINGS">FIG. 1</figref>, including a simulated linear bar graph meter display <b>36</b> representing the output value of the voltmeter. When the virtual instrument associated with the voltmeter is actuated, it acquires data from the voltmeter indicating the value of the presently measured voltage and adjusts the bar graph meter <b>36</b> to display that value. The voltmeter output value is also digitally displayed at the center of the bar graph meter.

The host computer is further adapted to perform a variety of computational or other functions (such as addition, multiplication and the like) and each such function takes the form of a corresponding virtual machine (such as an “adder”, “multiplier”, or the like) also graphically represented by a virtual front panel on terminal <b>22</b>. For convenience, these virtual machines may also be referred to as virtual instruments. Referring to <figref idref="DRAWINGS">FIG. 2C</figref>, the virtual front panel <b>38</b> of a “divider” virtual machine is illustrated for dividing a “numerator” parameter by a “denominator” parameter and outputting the result. The front panel includes three simulated meters: one logarithmic scale meter <b>40</b> displays the value of the “denominator”, a second linear scale meter <b>42</b> displays the value of the “numerator”, and a third linear graph meter <b>44</b> displays the divided result or “output”.

Referring to <figref idref="DRAWINGS">FIG. 2D</figref> a front panel <b>46</b> for a “logarithm” virtual machine, capable of obtaining the logarithm of any input “number” parameter number from 1 to 10 to any base from 1 to 10 (by way of example), includes a logarithmic dial meter <b>48</b> for displaying the input “number” parameter, a logarithmic dial meter <b>50</b> for displaying a selected input “base” parameter, and a linear graph meter <b>52</b> for displaying a “logarithm” parameter output. In <figref idref="DRAWINGS">FIG. 2E</figref>, a front panel <b>54</b> for a “multiplier” virtual machine, capable of producing an output parameter having a value equal to the product of two input parameter values, includes a linear scale meter <b>56</b> for showing the value “left” of one input value, a linear dial meter <b>58</b> for showing the value “right” of another input value, and a linear graph meter <b>60</b> “output” for showing the value of the product of the left and right input parameter values. It is apparent that many other virtual machines are possible and the foregoing are described only by way of example.

The present invention permits an operator to synthesize a higher order virtual machine for performing any selected sequence of operations, wherein each operation of the synthesized virtual machine is carried out by one or more selected pre-existing virtual machines in a given sequence. Referring to <figref idref="DRAWINGS">FIG. 1</figref>, and assuming that device under test <b>20</b> is, for example, an amplifier, the operator may wish to synthesize a “gainmeter” virtual instrument for determining the gain of the amplifier at some selected input voltage and frequency. To test amplifier gain, the signal generator <b>14</b> is set to produce a signal of the selected voltage and frequency, and this signal is applied to the amplifier input The resulting amplifier output voltage is measured by voltmeter <b>16</b> and the gain G of the amplifier is computed according to the following equation: <br />G=20*Log₁₀(V2/V1).  [A]<br /> where V<b>2</b> is the output voltage of the amplifier measured by the voltmeter and V<b>1</b> is the output voltage of the signal generator. Thus a gainmeter virtual instrument would implement an operation involving the use of a signal generator virtual instrument to produce V<b>1</b>, a voltmeter virtual instrument to produce V<b>2</b>, a divider virtual instrument (machine) to compute the ratio of V<b>2</b> to V<b>1</b>, a logarithm virtual instrument (machine) to find the log to the constant base of the output (V<b>2</b>/V<b>1</b>) of the divider virtual instrument, and a multiplier virtual instrument (machine) to find the product of a constant (<b>20</b>) and the output Log₁₀(V<b>2</b>/V<b>1</b>) of the logarithm virtual instrument.

Referring to <figref idref="DRAWINGS">FIG. 2F</figref>, a virtual front panel <b>62</b> is illustrated representing such a gainmeter virtual instrument, and includes meters <b>64</b> and <b>66</b> for displaying the values “inLevel” and “atFreq” for the voltage and frequency of the input signal applied, and a meter <b>68</b> for displaying the value “measuredGain” determined, by the synthesized gainmeter.

Software adapted to implement the preferred embodiment of the present invention is provided by way of example in the “Smalltalk-80” language. This language is described in detail in a book entitled Smalltalk-80, The Language and its Implementation, written by Adele Goldberg and David Robson and published by the Addison-Wesley Publishing Company in 1983, incorporated herein by reference. The Smalltalk-80 language treats numbers, character strings, programs, computational processes and the like as “objects” consisting of private memory for storing variables and a set of instructions (“methods”) for carrying out procedures in response to messages received from other objects. All similar objects comprise an object “class” with each individual object constituting an “instance” of its class. Each different type of virtual machine implemented in computer <b>22</b> comprises a separate object class and each virtual machine within a class is an instance of a class. For example, a class of virtual machines called “Divider” may include several examples of dividers, each operating in an identical fashion but used in different applications. A class may also be “empty” in the sense that while the operation of a virtual machine for the class is defined, there are no instances of the class being used in any application.

When an operator wishes to synthesize a new virtual instrument, such as a gainmeter, he creates new instances for every existing virtual instrument (machine) needed to perform the sequence of operations represented by the new virtual instrument. Referring to <figref idref="DRAWINGS">FIG. 3A</figref>, a “generator list” <b>70</b> is suitably initially displayed as a window on the screen of terminal <b>26</b> when the system is loaded on the host computer <b>22</b>. The generator list <b>70</b> lists the names of all existing virtual instrument classes. In this example, five virtual instrument classes are pre-existing: “Divider”, “Logarithm”, “Multiplier”, “SignalGenerator”, and “Voltmeter”. At the same time, an instance or instrument list <b>72</b>, shown in <figref idref="DRAWINGS">FIG. 3B</figref>, naming every instance of each class, is suitably displayed in a different window on the screen. In the particular example of <figref idref="DRAWINGS">FIG. 3B</figref> the instrument list <b>72</b> is empty, since no instance of any virtual instrument class has been created.

In order to synthesize the gainmeter virtual instrument, it is necessary to create new instances of the Divider, Logarithm, Multiplier, SignalGenerator and Voltmeter classes because the gainmeter virtual instrument will, utilize one instance from each of these classes in carrying out its function. To create such a new instance of a class, the operator selects the class by using the mouse connected to terminal <b>26</b> to move a cursor over the name of the class, such as “Divider” in the generator list <b>70</b>, and presses and releases the red mouse button to select the “Divider” name. Then the yellow button is depressed causing a first command menu <b>74</b>, as shown in <figref idref="DRAWINGS">FIG. 3C</figref>, to appear as a further window on the terminal screen. This first command menu displays a set of five command names: “new instance”, “synthesize”, “add”, “delete”, and “inspect me”. The operator then moves the cursor over the “new instance” command name and releases the yellow mouse button. Thereupon the first command menu window closes, and a new instance of the Divider class is created. The name of the new instance of the Divider class, “aDivider<b>12</b>”, is added to the instrument list <b>72</b> as shown in <figref idref="DRAWINGS">FIG. 3D</figref>, and a virtual front panel for the instrument, similar to that shown in <figref idref="DRAWINGS">FIG. 2C</figref>, is displayed in another window on the screen of terminal <b>26</b>. The name “aDivider<b>12</b>” is displayed at the top of the virtual instrument panel and indicates the instrument belongs to the Divider class. The number “<b>12</b>” at the end of the instance name is an arbitrary but unique number for each virtual instrument instance, used to distinguish this virtual instrument instance from any other virtual instrument instance.

In a similar manner, the operator uses the cursor and the first command menu <b>74</b> of <figref idref="DRAWINGS">FIG. 3C</figref> to create new instances of the Logarithm, Multiplier, SignalGenerator, and Voltmeter classes. Thereafter the instance or instrument list would appear as illustrated in <figref idref="DRAWINGS">FIG. 3E</figref>, listing the names of the new virtual instrument instances, “aDivider<b>12</b>”, “aLogarithm<b>13</b>”, “aMultiplier<b>14</b>”, “aSignalGenerator<b>15</b>”, and “aVoltmeter<b>16</b>”. The virtual front panels associated with each new virtual instrument instance, similar to those depicted in <figref idref="DRAWINGS">FIGS. 2A-2D</figref>, are also displayed as separate windows on the screen of terminal <b>26</b>.

Next, in order to create a new virtual instrument such as a gainmeter, the operator must create a new class, the class being assigned a suitable name such as “Gainmeter”. To create the new class the operator presses the yellow mouse button to cause the first command menu <b>74</b> of <figref idref="DRAWINGS">FIG. 3C</figref> to be displayed, moves the cursor over the “add” command, and then releases the yellow mouse button. The system then closes the first command menu window and opens a dialog window <b>78</b>, as illustrated in <figref idref="DRAWINGS">FIG. 3F</figref>, containing an upper portion <b>76</b> displaying a character string “add generator named:”, and a lower portion <b>80</b> for displaying a character string naming the new class, when provided by the operator. The operator types in the class name, such as “Gainmeter”, using the keyboard of terminal <b>26</b> and actuates a return button on the keyboard. The dialog window is then closed and the name “Gainmeter” is added to the generator list <b>70</b> as illustrated in <figref idref="DRAWINGS">FIG. 3G</figref>. At this time the system automatically produces software necessary to establish the new class according to a standard predefined template.

Once the Gainmeter class is created, the operator can “synthesize” the gainmeter, i.e., define the function an instance of the gainmeter class is to perform in terms of the functions which the existing virtual machines or instruments perform. To synthesize the gainmeter, the operator uses the cursor to select the Gainmeter item on the generator list <b>70</b> of <figref idref="DRAWINGS">FIG. 3G</figref> and operates a mouse button to open the first command menu <b>74</b> of <figref idref="DRAWINGS">FIG. 3C</figref>. The operator then employs the cursor and a yellow mouse button to select the “synthesize” command from the first command menu thereby causing the system to close the first command menu window and to display a new “synthesizing” window <b>82</b> as illustrated in <figref idref="DRAWINGS">FIG. 4</figref>. The synthesizing window includes three regions, a top region <b>84</b> for defining the virtual front panel associated with the virtual instrument being synthesized, a middle region <b>86</b> for displaying a Smalltalk listing of a procedure to be performed by the virtual instrument as it is generated, and a bottom region <b>88</b> containing a list of the input and output parameters associated with the procedure as well as output parameters for lower level virtual instruments and temporary variables. The parameters don't appear until the operator defines them.

An end product of the synthesizing process is a Smalltalk listing, displayed within region <b>86</b>, of a method named “runMe” which performs the gainmeter function, i.e., which accepts input data indicating the voltage and frequency of a signal to be applied to an input of a device under test, adjusts the signal generator of <figref idref="DRAWINGS">FIG. 1</figref> to produce such a signal, obtains the output voltage of the device measured by the voltmeter of <figref idref="DRAWINGS">FIG. 1</figref>, and computes the gain from the signal generator output voltage and the voltmeter reading. It is convenient to first discuss the completed listing for the runMe method of the gainmeter and then describe how the present invention assembles it. The Smalltalk code for the runMe method is as follows: <br />runMe  [1]<br />|q<b>5</b> q<b>4</b> q<b>3</b> q<b>2</b> q<b>1</b> t|  [2]<br />“Gainmeter”  [3]<br />“1 October 1985”  [4]<br />t ←(Generator InstrumentList) at: ‘aSignalGenerator<b>15</b>’.  [5]<br />t frequency: (self atFreq).  [6]<br />t amplitude: (self inLevel).  [7]<br />q<b>1</b> ←t runMe.  [8]<br />t ←(Generator InstrumentList) at: ‘aVoltmeter<b>16</b>’.  [9]<br />q<b>2</b> ←t runMe.  [10]<br />t ←(Generator InstrumentList) at: ‘aDivider<b>12</b>’. [<b>11</b>]<br />t denominator: (self inLevel).  [12]<br />t numerator: (q<b>2</b>).  [13]<br />q<b>3</b> ←t runMe.  [14]<br />t ←(Generator InstrumentList) at: ‘aLogarithm<b>13</b>’.  [15]<br />t number: (q<b>3</b>).  [16]<br />t base: <b>10</b>.  [17]<br />q<b>4</b> ←t runMe.  [18]<br />t ←(Generator InstmmentList) at: ‘aMultiplier<b>14</b>’.  [19]<br />t left: <b>20</b>.  [20]<br />t right: (q<b>4</b>).  [21]<br />q<b>5</b> ←t runMe.  [22]<br />^ self measuredGain: q<b>5</b> “Replace Me”  [23]

Line [<b>1</b>] is the title of the method, runMe. Line [<b>2</b>] declares q<b>5</b>, q<b>4</b>, q<b>3</b>, q<b>2</b>, q<b>1</b> and t as temporary variables. Line [<b>3</b>] is a comment identifying the runMe method as being associated with the Gainmeter and line [<b>4</b>] is a comment indicating the date when the runMe method was created. In line [<b>5</b>] the variable t is made to reference the aSignalGenerator<b>15</b> object on the Generator InstrumentList. In other words, when the variable t is then used to designate an object, the designated object is the aSignalGenerator<b>15</b> virtual instrument. In line [<b>6</b>] a message is sent to the aSignalGenerator<b>15</b> virtual instrument which assigns the value of the Gainmeter (referenced by the word “self”) input parameter atFreq to the frequency input parameter of aSignalGenerator<b>15</b>. In line [<b>7</b>] a message is sent to the aSignalGenerator<b>15</b> object which assigns the value of the gainmeter input parameter inLevel to the amplitude input parameter of aSignalGenerator<b>15</b>. In line [<b>8</b>] a “runMe” message is sent to the aSignalGenerator<b>15</b> virtual instrument which causes it to set the frequency and amplitude controls of the signal generator <b>14</b> of <figref idref="DRAWINGS">FIG. 1</figref> consistent with the atFreq and inLevel input values provided in lines [<b>6</b>] and [<b>7</b>]. Also in line [<b>8</b>] an output of the aSignalGenerator<b>15</b> runMe method, an indication of method completion, is assigned to a variable q<b>1</b>.

In line [<b>9</b>] the t variable is reassigned to reference the aVoltmeter<b>16</b> virtual instrument on the generator instrument list and in line [<b>10</b>] a runMe message is sent to the aVoltmeter<b>16</b> virtual instrument causing it to acquire the output voltage measured by the voltmeter <b>16</b> of <figref idref="DRAWINGS">FIG. 1</figref> and to assign the value of the measured voltage (V<b>2</b> in equation [A] hereinabove) to another variable q<b>2</b>.

In line [<b>11</b>] the variable t is reassigned to reference the aDivider<b>12</b> virtual instrument and in lines [<b>12</b>] and [<b>13</b>] messages are sent to aDivider<b>12</b> causing it to assign the value of the inLevel gainmeter input parameter (V<b>1</b> in equation [A] hereinabove) to the denominator parameter of aDivider<b>12</b> and to assign the q<b>2</b> variable (i.e., V<b>2</b>) of line [<b>10</b>] to the numerator parameter of aDivider<b>12</b>. In line [<b>14</b>] a runMe message is sent to aDivider<b>12</b> causing it to divide the numerator parameter by the denominator parameter thereby producing an output quantity equal to V<b>2</b>/V<b>1</b>. Also in line [<b>14</b>] the aDivider<b>12</b> output is assigned to another variable q<b>3</b>.

In line [<b>15</b>] the variable t is reassigned to reference the aLogarithm<b>13</b> virtual instrument and in lines [<b>16</b>] and [<b>17</b>] messages are sent to aLogarithm<b>13</b> causing it to assign the value of the q<b>3</b> variable (V<b>2</b>/V<b>1</b>) to the number parameter of aLogarithm<b>13</b> and to assign the constant <b>10</b> to the base parameter of aLogarithm<b>13</b>. In line [<b>18</b>] a runMe message is sent to aLogarithm<b>13</b> causing it to produce an output quantity equal to the log to the base <b>10</b> of number (i.e., Log₁₀(V<b>2</b>/V<b>1</b>)). This quantity is assigned to the variable q<b>4</b>.

In line [<b>19</b>] the variable t is reassigned to reference the aMultiplier<b>14</b> virtual instrument and in lines [<b>20</b>] and [<b>21</b>] messages are sent to aMultiplier<b>14</b> requesting it to assign the constant <b>20</b> to its left parameter and to assign the variable q<b>4</b> produced in line <b>18</b> as its right parameter. In line [<b>22</b>] a runMe message is sent to aMultiplier<b>14</b> causing it to produce an output quantity equal to the 20 times q<b>4</b>, i.e., <b>20</b>Log₁₀(V<b>2</b>/V<b>1</b>). This output quantity is assigned to the variable q<b>5</b>. Finally, in line [<b>23</b>], the measured gain of the device under test q<b>5</b> is assigned as the Gainmeter output parameter, measuredGain, and this value is returned.

The above runMe method listing for the gainmeter virtual instrument is produced during the synthesis process and displayed in region <b>86</b> of the synthesizing window <b>82</b> of <figref idref="DRAWINGS">FIG. 4</figref>. Initially, when the window is opened, lines [<b>1</b>]-[<b>4</b>] are automatically displayed in region <b>86</b>, followed by a fifth line: <br />^ self myValue: self myValue “replace me”  [23a]<br /> This last line is a precursor to line [<b>23</b>] of the runMe listing wherein the instance of “myValue:” is a dummy variable subsequently to be replaced during the synthesizing process by “measuredGain:” and wherein the following “self myValue” dummy expression is subsequently to be replaced by the “q<b>5</b>” variable as described hereinbelow. The remaining lines [<b>5</b>]-[<b>22</b>] are also inserted into the listing during the synthesizing process.

Referring again to the synthesizing window <b>82</b> of <figref idref="DRAWINGS">FIG. 4</figref>, the top region <b>84</b> of window <b>82</b> is divided into three subregions. The first subregion <b>90</b> of top region <b>84</b> contains a list of the names of the input and output parameters of the synthesized virtual instrument. Initially subregion <b>90</b> is empty because the input and output parameters of the instrument have not been defined. A second subregion <b>92</b> of window region <b>84</b> contains a list of parameter types and a pair of selection boxes <b>94</b> and <b>96</b> for indicating whether a parameter is an input or an output of the synthesized virtual instrument. In this example, the possible parameter types include “function” (e.g., selection from a list such as square, sine, triangle), and “number” (a floating point decimal number). However, in other applications, other types of parameters may be included in the parameter type list including integers, character strings, binary numbers, etc. A third subregion <b>98</b> of window region <b>84</b> includes a list of the possible types of virtual front panel displays available for each parameter including in the present example, “linearGraph”, “linearMeter”, “logGraph”, and “logMeter” which are adapted to display the value of a number. The “volts” display <b>36</b> of the voltmeter virtual front panel of <figref idref="DRAWINGS">FIG. 2B</figref> is an example of a linearGraph display wherein the value of a parameter is displayed as a bar of proportional length. The “left” meter <b>56</b> of the multiplier virtual front panel of <figref idref="DRAWINGS">FIG. 2E</figref> is an example of a linearMeter display wherein the value of a parameter is proportional to the position of a pointer on a dial. The “inLevel” display <b>64</b> and the “atFreq” <b>66</b> displays of the gainmeter of <figref idref="DRAWINGS">FIG. 2F</figref> are examples of the logGraph and logMeter displays wherein, respectively, the value of parameter is logarithmically proportional to the length of a bar or the position of a pointer on a dial. In other applications of the present invention, the list of possible displays in subregion <b>98</b> may be expanded to provide for displays of other types of parameters including, for example, an alphanumeric readout for displaying character strings, simulated lamps for displaying binary parameter states, selectors from lists, etc.

The operator may define an input or output parameter for the synthesized instrument by adding it to the parameter list in subregion <b>90</b>. First the cursor is moved over the subregion and a yellow mouse button is pressed to open a second command menu window <b>100</b> as illustrated in <figref idref="DRAWINGS">FIG. 3H</figref> superimposed over region <b>90</b>. This window includes four commands, “add”, “delete”, “new instance” and “inspect parameter”. The operator then moves the cursor over the “add” command and releases the mouse button. The system then closes the second command window and opens a dialog window similar to that shown in <figref idref="DRAWINGS">FIG. 3F</figref>, except requesting “add parameter named”. At this point the operator types the name of a parameter such as “atFreq” and then presses a carriage return button on the terminal keyboard. The system displays the name “atFreq” in subregion <b>90</b> with the name highlighted and also highlights the “input” selection box in subregion <b>92</b> as well as the “linearGraph” display type in subregion <b>98</b>, to indicate that the highlighted parameter atFreq is, by default, a floating point number input to the gainmeter to be displayed as a linear graph on the virtual front panel for the gainmeter. The operator may change the nature of the front panel display for a parameter in highlighted subregion <b>90</b> by placing the cursor over the desired display type in subregion <b>98</b> and depressing the red mouse button. Similarly the operator may change the parameter type and whether it is an input or an output by using the cursor and red button to select the appropriate defining words in subregion <b>92</b>. Next, in the same manner in which the operator used the cursor in the second command window to add and define the atFreq parameter, the operator also adds and defines the “inLevel” and “measuredGain” parameters. At this point all three parameters appear in the input/output parameter list of subregion <b>90</b> as seen in <figref idref="DRAWINGS">FIG. 4</figref>.

Each time the operator adds an input or an output parameter to the parameter list of subregion <b>90</b>, a line is added to region <b>88</b> listing the parameter. As shown in <figref idref="DRAWINGS">FIG. 4</figref>, the first line in the “bind list” of region <b>88</b> reads “self atFreq” indicating a parameter atFreq has been defined according to the front panel specifications of the gainmeter (“self”), rather than according to the specifications of some other virtual instrument on the instrument list. Similarly, when the operator adds the inLevel and measuredGain parameters to the parameter list of subregion <b>90</b>, the system displays second and third lines in region <b>88</b> reading “self inLevel” and “self measuredGain”.

At this point the operator has defined the virtual front panel for the gaimneter, as illustrated in <figref idref="DRAWINGS">FIG. 2F</figref> wherein the gainmeter virtual front panel is analogous to a “real” front panel as would be required for a “real” gainmeter and which could be constructed from hardware components. A real front panel for a gainmeter would include a knob for controlling and indicating output signal frequency, a knob for controlling and indicating output signal voltage, and a meter for displaying gain. In order to construct a “real” gainmeter it would be necessary to interconnect the front panel with inputs and outputs of various hardware components capable of producing a test signal, to measure a voltage and to perform a gain calculation. Similarly, in order to cause the virtual front panel of a virtual gainmeter instrument to operate properly it is necessary to create the runMe code for the gainmeter virtual instrument for directing the flow of messages which “interconnect” the gainmeter virtual front panel with the aDivider<b>12</b>, aLogarithm<b>13</b>, aMultiplier<b>14</b>, aSignalGenerator<b>15</b> and aVoltmeter<b>16</b> virtual instruments, in a fashion analogous to the wired interconnection of corresponding hardware instruments.

First, the operator selects the first virtual instrument to be utilized by the gainmeter, aSignalGenerator<b>15</b>, by moving the cursor over the displayed virtual front panel for the aSignalGenerator<b>15</b>, illustrated in <figref idref="DRAWINGS">FIG. 2A</figref>, and clicking a button on the mouse. The “a SignalGenerator<b>15</b>” label on the front panel is then highlighted to indicate the selection. To test the operation of the virtual signal generator and the corresponding real signal generator, the operator may set test values for the frequency and amplitude input parameters of the virtual signal generator, operate the virtual signal generator and then measure the output of the corresponding real signal generator to see if it produces a signal with the desired voltage and frequency characteristics. To adjust an input parameter of a virtual instrument after selecting the instrument, the operator moves the cursor over the meter area of a panel meter or a bar graph meter, depresses a red selection button on the mouse, moves the cursor to move the pointer or the bar to the desired position on the meter, and releases the red button. This is analogous to moving a knob or a slide control on a real front panel. Alternatively, the operator may select a meter and then operate a yellow button on the mouse to open a third command menu window <b>102</b> as illustrated in <figref idref="DRAWINGS">FIG. 3I</figref> listing “generate”, “run”, “stop”, “inspect me” and “set parameters” commands. When the operator selects the set parameters command with the cursor, third command menu window <b>102</b> is replaced with a dialog window <b>104</b> as illustrated in <figref idref="DRAWINGS">FIG. 3K</figref>. In the example of <figref idref="DRAWINGS">FIG. 3K</figref> the operator has select ed the frequency meter of the signal generator virtual front panel <b>28</b> of <figref idref="DRAWINGS">FIG. 2A</figref>. The dialog window <b>104</b> requests the operator to type in a new value for frequency. In this example, the operator has responded by typing in “1325”. When the operator presses the carriage return, the dialog window <b>104</b> disappears and the frequency meter <b>30</b> of <figref idref="DRAWINGS">FIG. 2A</figref> is set to the new value. Assuming that the operator has now set the frequency parameter to 1325 and the voltage parameter to 5.59, the operator may “run” the signal generator virtual instrument by opening the third command menu window <b>102</b> of <figref idref="DRAWINGS">FIG. 3I</figref> and selecting the “run” command. This causes the signal generator virtual instrument to send the frequency and amplitude data to the real signal generator <b>14</b> of <figref idref="DRAWINGS">FIG. 1</figref> along with a signal causing it to operate. The operator may then test the output of the real signal generator to see if it produces a signal of the desired voltage and frequency. After the output of the signal generator <b>14</b> is tested, the operator may stop the operation of the signal generator by selecting the virtual signal generator, opening the third command menu window of <figref idref="DRAWINGS">FIG. 3I</figref>, and selecting the “stop” command, thereby causing the virtual signal generator to send a stop instruction to its real counterpart.

Once operation of the virtual signal generator is verified (if such is desired), the code for “connecting” the virtual signal generator to the aGainmeter<b>1</b> front panel may be synthesized. First, the operator uses the cursor and a red mouse button to select the last line of the listing currently displayed in region <b>86</b> of the synthesizing window of <figref idref="DRAWINGS">FIG. 4</figref>. The operator then selects the aSignalGenerator<b>15</b> front panel, uses a mouse button to open the third command menu window <b>102</b> of <figref idref="DRAWINGS">FIG. 3I</figref>, and selects the “generate” command. This causes the system to insert the following code lines immediately preceding the selected line, in this case the last line in region <b>86</b>: <br />t ←(Generator InstrumentList) at: ‘a SignalGenerator<b>15</b>’.  [5]<br />t frequency:1325.  [6a]<br />t amplitude:5.59.  [7a]<br />q<b>1</b> ←t runMe.  [8]<br /> These lines are similar to lines [<b>5</b>]-[<b>8</b>] of the completed runMe listing except that in lines [<b>6</b>a] and [<b>7</b>a] the frequency variable is assigned its current test setting of 1325 Hertz and the amplitude variable is assigned its current test setting of 5.59 volts rather than the values of atFreq and inLevel indicated in lines [<b>6</b>] and [<b>7</b>] of the completed listing. At the same time lines [<b>5</b>], [<b>6</b>a], [<b>7</b>a], and [<b>8</b>] are added to the listing in region <b>86</b>, the q<b>1</b> variable produced in line [<b>8</b>] is added to the bind list in region <b>88</b>, as well as to the temporary variable declarations in line <b>2</b>.

The operator may now “connect” the inLevel and atFreq parameters of the Gainmeter so that the virtual signal generator inputs may be set from the inLevel and atFreq inputs of the Gainmeter. To connect the atFreq parameter to the frequency input of the aSignalGenerator virtual instrument, the operator uses the cursor and a red selection button on the mouse to select line [<b>6</b>a] of the listing in region <b>86</b> and the “self atFreq” line of the bind list in region <b>88</b> and then operates a yellow selection button on the mouse to open a fourth command menu window <b>106</b> as illustrated in <figref idref="DRAWINGS">FIG. 3J</figref>. The fourth command menu window lists the commands “modify code”, “delete”, “clear”, and “inspect”. At this time, the operator selects the modify code command which causes the system to modify the code of line [<b>6</b>a] so that it reads as in line [<b>6</b>] of the completed, runMe listing hereinabove by replacing the number 1325 with “(self atFreq)”. In a similar fashion, the operator modifies Line [<b>7</b>a] to read as in line [<b>7</b>] of the completed listing by selecting line [<b>7</b>a] in region <b>86</b>, selecting the “self inLevel” line from the bind list in region <b>88</b> and then selecting the modify code command from the fourth command window <b>106</b> of <figref idref="DRAWINGS">FIG. 3J</figref>.

Next the operator selects the aVoltmeter <b>16</b> front panel <b>34</b> of <figref idref="DRAWINGS">FIG. 2B</figref> and may test its operation by applying a known reference voltage to voltmeter <b>16</b> of <figref idref="DRAWINGS">FIG. 1</figref>, selecting the “run” command of the third command menu <b>102</b>, and checking meter <b>36</b> of the aVoltmeter<b>16</b> front panel to see that it properly indicates the reference voltage. The operator then inserts lines [<b>9</b>] and [<b>10</b>] into the runMe listing in region <b>86</b> by selecting the last line of the listing, selecting the aVoltmeter<b>16</b> front panel, and then selecting the “generate” command from the third command menu <b>102</b> of <figref idref="DRAWINGS">FIG. 3I</figref>. <br />t ←(Generator InstrumentList) at:“aVoltmeter<b>16</b>”.  [9]<br />q<b>2</b> ←t runMe.  [10]<br /> At the same time these lines are inserted into the listing in region <b>86</b>, the q<b>2</b> variable is added to the bind list in region <b>88</b> and to the temporary variables in line <b>2</b> of region <b>86</b>.

In similar fashion the following lines are added to the listing in region <b>86</b> when the operator selects the aDivider<b>12</b> instrument and the generate command of the command menu <b>102</b> of <figref idref="DRAWINGS">FIG. 3I</figref>: <br />t ←(Generator InstrumentList) at: “aDivider<b>12</b>”.  [11]<br />t denominator: 1.  [12a]<br />t numerator: 1.  [13a]<br />q<b>3</b> ←t runMe.  [14]<br /> The q<b>3</b> variable is also added to the bind list in region <b>88</b> of the synthesizing window <b>82</b> of <figref idref="DRAWINGS">FIG. 4</figref>, and to line <b>2</b> of region <b>86</b>. At this point the operator modifies line [<b>12</b>a] to replace the “1” constant with (self inLevel) by selecting line <b>12</b>a and the “self inLevel” parameter in region <b>88</b>, and then selecting the modify code command from the command menu <b>106</b> of FIG.. <b>3</b>J. The operator also modifies line [<b>13</b>a] in similar manner except that the q<b>2</b> variable in the bind list of region <b>88</b> is selected to replace the constant “1” in line [<b>13</b>a].

In a similar fashion, the operator may select and use the generate and modify code commands of the menu of <figref idref="DRAWINGS">FIG. 3J</figref> to insert code lines [<b>15</b>]-[<b>22</b>] into the runMe listing for the aGainmeter<b>1</b> virtual instrument displayed in region <b>86</b> of the synthesizing window. Finally, the operator must modify the last line [<b>23</b>a] of the code in region <b>86</b> to match line [<b>23</b>] of the completed runMe listing. To do so the operator selects line [<b>23</b>a] and uses a mouse button to open a command menu window <b>108</b> of <figref idref="DRAWINGS">FIG. 3L</figref> which lists the commands “modify code”, “edit code”, “add code”, clear code“, “reset code”, “compile message”, and “inspect code”. The operator selects the “edit code” command in the menu and the menu is then replaced with dialog window <b>110</b> as illustrated in <figref idref="DRAWINGS">FIG. 3M</figref> which contains selected code line [<b>23</b>a]. This dialog window permits the operator to use the cursor to indicate the dummy variables to be replaced and to type in the appropriate information (as hereinbefore mentioned) in their place.

With the runMe code for the gainmeter synthesized, the complete code for the gainmeter virtual instrument may now be compiled. To do so, the operator opens the command menu window <b>108</b> of <figref idref="DRAWINGS">FIG. 3L</figref> and selects the “compile message” command. Once the code is compiled, the synthesis process for the Gainmeter class is complete and the operator may create an instance of the Gainmeter class by selecting the “Gainmeter” class from the Generator list window <b>70</b> of <figref idref="DRAWINGS">FIG. 3G</figref>, opening the command menu window <b>74</b> of <figref idref="DRAWINGS">FIG. 3C</figref> (or opening the command window <b>100</b> of <figref idref="DRAWINGS">FIG. 3H</figref> in region <b>90</b>, of the synthesizing window of <figref idref="DRAWINGS">FIG. 4</figref>), and selecting new instance. Thereafter the aGainmeter<b>1</b> virtual front panel <b>62</b> of <figref idref="DRAWINGS">FIG. 2F</figref> is displayed.

This instance of the gainmeter virtual instrument may be operated in the same manner any other virtual instrument is operated. The inLevel and atFreq control inputs may be modified by using the cursor to set the appropriate meter settings (or by typing the desired values into a dialog window) and then selecting the run command from the command menu of <figref idref="DRAWINGS">FIG. 3I</figref>.

When the operator no longer wishes the front panel of a virtual instrument to be displayed, he may select such front panel and then open the blue button menu window <b>112</b> as illustrated in <figref idref="DRAWINGS">FIG. 3N</figref>, displaying “under”, “move”, “frame”, “collapse”, and “close” commands. The close command removes the selected panel from view, the under command causes a selected window to appear beneath any overlapping windows, and the move command permits the operator to relocate any selected window by using the cursor to move the window across the screen to a new position. The frame command permits the operator to use the cursor to resize a window by moving a corner of the window. The collapse command shrinks a selected window until only its title is shown on the screen. A collapsed window may be opened again by selecting the frame command from the blue button menu. It will be realized that all these functions are performed by commercially available graphics software, such as Smalltalk <b>80</b>.

Referring to <figref idref="DRAWINGS">FIG. 3C</figref>, the command menu <b>74</b> includes a delete and an inspect me command in addition to the new instance, synthesize and add commands previously discussed. The operator may delete an instrument class by selecting the class on the generator list <b>70</b> of <figref idref="DRAWINGS">FIG. 3G</figref>, opening command menu <b>74</b> of <figref idref="DRAWINGS">FIG. 3C</figref> and selecting the delete command. The inspect me command invokes a standard Smalltalk feature which enables the operator to obtain information regarding a selected object, in this case a virtual instrument class. The add code command of the command menu of <figref idref="DRAWINGS">FIG. 3L</figref> permits an operator to type in a line of code in a selected location within the runMe listing region <b>86</b> and the clear code command permits the operator to clear the entire code. The delete command permits him to delete a selected line of code. The reset code command permits the operator to restore the code to the initial value as in <figref idref="DRAWINGS">FIG. 4</figref>.

The Smalltalk software for the preferred embodiment of the present invention is implemented using three system categories: “MyInstruments”, “Synthesizer”, and “InterfaceMeters”. The MyInstruments system category includes virtual instrument classes. Appendix I also found in parent application Ser. No. 06/798,931, filed Nov. 18, 1985, now U.S. Pat. No. 4,849,880 includes listings for example virtual instrument classes for adding and multiplying.

The Adder virtual instrument class listing appears on the first page of Appendix I and will be discussed in detail by way of example. The other virtual instrument class listings are structured in a similar fashion as will be apparent to those skilled in the art.

Referring to the Adder virtual instrument class listing, line (<b>1</b>) identifies the virtual instrument subclass “Adder” and line (<b>2</b>) defines three instance variables: left, output and right. Lines (<b>3</b>) and (<b>4</b>) indicate the VirtualInstruments class has no class variables and no pool dictionaries. Line (<b>5</b>) identifies the class category, myInstruments.

Each instrument subclass has two groups of instance methods, “parameters” and “set values”. The parameters methods include methods to set and read the values of selected instance variables and a runMe method to carry out the operation of the virtual instrument. The setValues methods provide the prompt in dialog windows of the type shown in <figref idref="DRAWINGS">FIG. 3K</figref> when the operator uses the “set frequency” command of the command menu of <figref idref="DRAWINGS">FIG. 3I</figref> to specify a frequency value. When a different meter is selected, the word frequency in menu <b>102</b> is replaced by the name of the parameter displayed by the meter.

Line (<b>6</b>) introduces the parameter methods and line (<b>7</b>) defines a first parameter method corresponding to the selector “left” which returns the value of the left variable to any object sending a “left” message to the adder. If the value of the left variable has never been set, i.e., it is “Nil”, the method sets the value of the left parameter to 1 and returns 1 as the parameter value. This line also includes comments indicating the date when the method was last modified, the variable type (number), the type of meter used to display the variable (linearGraph), and whether the variable is an input or an output. Line (<b>8</b>) defines a second parameter method responding to the selector “left:”. This method sets the value of the left variable to any value specified in a message of the form left:xx, where xx is the specified value. The method returns the set value of left to the message sender. Similarly, lines (<b>9</b>), (<b>10</b>), (<b>11</b>) and (<b>12</b>) define methods responding to the selectors “output”, “output:”, “right”, and “right:” which permit the interrogation and setting of the output and right variables in the same manner that lines (<b>7</b>) and (<b>8</b>) permit interrogation and setting of the left variable.

Lines (<b>13</b>)-(<b>18</b>) define the parameter method executed in response to a runMe method. Line (<b>13</b>) recites the runMe selector and lines (<b>14</b>) and (<b>15</b>) are comments indicating the class (Adder) and the date of creation of the class. Line (<b>16</b>) defines a temporary variable, t. In line (<b>17</b>) the value of the left parameter and the value or the right parameter are obtained by using the left and right methods of lines (<b>7</b>) and (<b>11</b>). The two values are summed and the sum is assigned to a variable “my Value” which is returned to the object which sent the runMe message. Line <b>17</b> also invokes the “output:” method to set the output parameter on the virtual front panel of an adder.

Line (<b>19</b>) introduces the setValues methods, the first of which is defined in line (<b>20</b>) as responsive to a message containing a “setleft” selector. This line returns a character string “left value?” to be placed in a dialog window when the operator is to type in a new parameter value after having invoked the setleft command. The methods of lines (<b>21</b>) and (<b>22</b>) are similar to the method of line <b>20</b> except that line (<b>21</b>) relates to the setting of the output parameter and line (<b>22</b>) relates to the setting of the right parameter.

The above listing for the Adder subclass is structured in a fashion which is typical for all virtual instrument subclasses, each having a pair of parameter methods similar to “left” and “left:” of lines (<b>7</b>) and (<b>8</b>) and a setValues method similar to that of line (<b>20</b>) associated with each parameter. Also each has a runMe method similar to that given in the adder example and designed to implement the primary function of the virtual instrument. The code for the runMe method, associated a virtual instrument which sends data to and/or receives data from a real instrument such as a signal generator or a voltmeter, includes provisions for sending data out on the bus to the receiving instrument and/or acquiring data over the bus from the instrument in a well known manner.

Appendix II also found in U.S. Pat. No. 4,849,880 is a listing of a new Smalltalk system category “Synthesizer, according to the present invention, which includes three new Smalltalk classes: “Generator”, “ParameterBlok”, and “VirtualInstruments”. Generator is a new subclass of the standard Smalltalk class “Object” while Parameterblok and VirtualInstruments are new subclasses of the standard Smalltalk class “Number”. Each virtual instrument class is a subclass of VirtualInstruments. The Generator class, also diagrammed in <figref idref="DRAWINGS">FIG. 6</figref>, includes instance methods <b>120</b> and class methods <b>122</b> invoked during the creation of new classes of virtual instruments and new virtual instrument instances, and invoked to control the operation of the virtual instruments instances. The ParameterBlok class, also diagrammed in <figref idref="DRAWINGS">FIG. 7</figref>, includes a class method <b>124</b> and an instance method <b>126</b> invoked to create and maintain records of the attributes (i.e. name, type, value, meter view, etc.) of the various input and output parameters associated with each virtual instrument. The VirtualInstruments class, also diagrammed in <figref idref="DRAWINGS">FIG. 8</figref>, includes class methods <b>128</b> and instance methods <b>130</b> also invoked during the creation of virtual instrument instances, providing common display messages for the virtual instrument classes.

The virtual instrument classes are used as “generators” to generate new virtual instrument instances, and these classes are included in a data structure called “GeneratorList”. The names of these generator classes are displayed on a generator list <b>70</b> illustrated in <figref idref="DRAWINGS">FIG. 3D</figref>. The names of the virtual instrument instances available for a project are displayed on an instrument list <b>72</b> as illustrated in <figref idref="DRAWINGS">FIG. 3E</figref>.

Referring to <figref idref="DRAWINGS">FIG. 6</figref>, the generator class is initialized by an “initialize” method which calls an “addGeneratorSpec: parameters:” method to add the available virtual instruments to the generator list and to invoke a “compileGenerator:” method which compiles the generator classes. Initially when an operator opens a project, the operator types and executes the line, “Generator example”. This calls the generator class method “example” which in turn calls the methods “displayGenerators” and “displayInstruments” to initiate the display of the generator list <b>70</b> of <figref idref="DRAWINGS">FIG. 3C</figref> and the instrument list <b>72</b> of <figref idref="DRAWINGS">FIG. 3B</figref>. Once the generator list is displayed, the operator may select a generator using the cursor and the red mouse button, thereby invoking a “wakeGenerators” method which sets a variable indicating the selected generator. The operator may open the generator command menu <b>74</b> of <figref idref="DRAWINGS">FIG. 3C</figref> by operation of the yellow mouse button which invokes a “generatorMenu” method for displaying the menu. The operator may delete the selected generator from the generator list by selecting the delete command from the menu, calling a “deleteGenerator” method. The operator may inspect a selected generator by selecting the inspect me command from the menu whereupon an “inspectSelectedGenerator” method is called which invokes a standard Smalltalk inspect method.

The operator may add an instance of a virtual instrument to the instrument list by selecting the appropriate generator on the generator list and then selecting the new instances command on the generator menu <b>74</b> of <figref idref="DRAWINGS">FIG. 3C</figref>. An “addInstrument” method is called which obtains the name of the selected generator and passes it to an “addInstrument:” method. The “addInstrument:” method adds the name of the virtual instrument instance to the instrument list and invokes a “newInstance” method which initiates display of the virtual front panel for the new virtual instrument. The “addInstrument:” method also invokes a VirtualInstruments class method “new:” (listed in <figref idref="DRAWINGS">FIG. 8</figref>) which creates the new instance of the instrument and initializes it with a name and a parameter block. The “new:parameters:” method calls a VirtualInstruments instance method “initialize:”, setting the values of the parameters in the parameter block associated with the new virtual instrument instance.

The operator may select a virtual instrument instance on the instrument list using the cursor and the red mouse button and may open an instrument command menu <b>73</b> as illustrated in <figref idref="DRAWINGS">FIG. 3P</figref> by depressing the yellow mouse button when the cursor is within the instrument list. The front panel of a selected virtual instrument is displayed if the operator selects a “show me” command from the instrument command window, invoking a “showSelectedInstrument” method to initiate the display. The operator may “run” a selected virtual instrument by selecting the run command which calls a “runSelectedInstrument” method for sending a “runMe” message to the selected virtual instrument. The operator may add a new instance of a selected virtual instrument by selecting the add command to invoke the “addInstrument” method discussed hereinabove. The operator may inspect a selected virtual instrument by choosing the inspect command which calls an “inspectInstrument” method invoking the Smalltalk inspect method, and can delete a selected virtual instrument instance by selecting the delete command from the instrument list menu to call for a “deleteInstrument” method for removing the selected instrument from the instrument list. The generate command on the instrument menu is discussed hereinbelow in conjunction with the synthesis process methods.

When a virtual front panel is displayed, the operator may open the meter menu <b>102</b> of <figref idref="DRAWINGS">FIG. 3I</figref> by placing the cursor over a meter and operating the yellow button to call for a “makeYBM:” instance method of the virtualInstruments class (<figref idref="DRAWINGS">FIG. 6</figref>). Referring to <figref idref="DRAWINGS">FIG. 6</figref>, the run, stop and inspect me commands invoke, respectively, a “run” method for sending a runMe message to the virtual instrument, a “stopMe” method for sending a stopMe message halting instrument operation, and an “InspectMe” method invoking the Smalltalk “inspect” method. The set parameter command on the meter menu invokes a “setValue” method for opening a dialog window permitting the operator to type in a new value for the parameter displayed by a selected meter and sets the parameter to the new value. The generate command on the meter menu will also be discussed hereinbelow in conjunction with the synthesis process.

In order to synthesize a new generator, the operator first adds the generator to the generator list. To do so the operator uses the add command on the generator command menu <b>74</b> of <figref idref="DRAWINGS">FIG. 3C</figref>. Referring to <figref idref="DRAWINGS">FIG. 6</figref>, this command calls an “addGenerator” method for opening a dialog window permitting the operator to type in the name of the new generator and then calls an “addGenerator:” method which adds the generator name to the generator list and invokes a generator “new:” method. The “new” method creates a new generator instance and provides an instance method “initialize:” which creates the initial Smalltalk code listing for the runMe method for the new generator class. This initial listing includes the runMe code lines [<b>1</b>]-[<b>4</b>] and [<b>22</b>a] described hereinabove. These lines are obtained by a call to an “initialCodeList:” Generator class method which returns the code lines. The “initialize” method also initializes parameter and bind lists for the generator. After the “addGenerator:” method is completed, the “addGenerator” method invokes a “compileGenerator:” method which creates the new class by calling a standard Smalltalk method subclass:instanceVariableNames:classVariableNames:poolDictionaries:category:. The method “compileGenerator:” invokes the “makeParameterMessage:in:” Generator instance method which creates the parameter methods for the generator.

Once a generator appears an the generator list, the operator may “synthesize” the generator (i.e., alter its function) by opening the synthesis window. When the operator selects a generator to be synthesized from the generator list and utilizes the synthesize command on the generator menu, a “synthesis” Generator class method is called. This method then invokes the “displaySynthesis” instance method for the selected generator which opens the synthesis window <b>82</b> of <figref idref="DRAWINGS">FIG. 4</figref>. The window displays any existing input or output parameters on the parameter list in region <b>90</b> of the window and on the bind list in region <b>88</b>, and displays the runMe code for the generator in region <b>86</b>. When the operator opens the parameter menu <b>100</b> of <figref idref="DRAWINGS">FIG. 3H</figref>, a “parameterMenu” instance method is called to display the menu. The operator may add a parameter to the list by selecting the add command which calls an “addParameter” method for displaying a dialog window enabling the operator to type in a new input/output parameter name. After the name is typed in, “addParameter” passes the name to an “addParameter:” method which forwards the parameter name to an “addParameterToList:” method for adding the parameter to the parameter list. Before adding the parameter to the parameter list the “addParameterToList:” method initializes the parameter attributes (i.e. view, type, input/out) to default values by invoking a “setParameter:blok:” instance method. The “setParameter:blok:” method calls a set of ParameterBlok class instance methods (listed in <figref idref="DRAWINGS">FIG. 6</figref>) “in:”, “out:”, “name:”, “type:”, “value:” and “view:”. These methods specify the attributes of the parameter. The “addParameter” method also passes the parameter name to a “makeParameterMessage:in:” method which adds the parameter to the list of instance variables for the generator class, adds the variable to the bind list, and creates the instance methods for the class being synthesized for setting and returning the value of the new parameter.

A new parameter is initialized as an input of the “number” parameter type to be displayed on a linear graph. The operator may change these parameter attributes by using the cursor and the red mouse button to select the parameter and then the appropriate parameter attributes in region <b>84</b> of the synthesizing window. When either the Input or the Output parameter attribute is selected, or deselected, the “in:” or the “out:” parameter block instance method is invoked to set the input/output attribute for the parameter. When a parameter type (i.e., number or function) or parameter view (i.e., linearGraph, linearMeter, etc.) is selected, a “type:” method or “view:” method is used to set the selected parameter type or view. Whenever the operator selects a parameter on the parameter list, a “wakeParameter:” Generator instance method is called which highlights the selected parameter and the appropriate attributes displayed in region <b>84</b> of the window. The “wakeParameter:” method determines the appropriate view, type and input/output parameter attributes by invoking the parameterBlok methods (“view”, “type”, “in”, and “out”) and passing the returned data to instance methods (“sView:”, “sType:”, “myIn:”, and “myOut:”) which control the highlighting of the attributes. The “wakeParameter:” method then modifies the display by calling a standard Smalltalk method “changed:”.

The operator can delete a parameter from the parameter list by selecting the parameter to be deleted and then selecting the delete command from the parameter menu <b>100</b> of <figref idref="DRAWINGS">FIG. 3H</figref>, thereby calling for a “deleteParameter” Generator instance method which removes the parameter from the parameter and bind lists and updates the display. The operator can also inspect the parameter by selecting the inspect command from the parameter command menu to call an “inspectParameter” method which in turn invokes the Smalltalk inspect method. The operator can also create a new instance of the selected generator virtual instrument by selecting the “new instance” on the parameter command window of <figref idref="DRAWINGS">FIG. 3</figref>. This calls a “newInstance” Generator instance method which utilizes the generator class method “newInstance” discussed hereinabove.

As part of the synthesizing process, the operator may insert new lines into the runMe listing in region <b>86</b> of the synthesizing window <b>82</b> of <figref idref="DRAWINGS">FIG. 4</figref> which cause a synthesized virtual instrument to utilize another virtual instrument to perform a selected operation. First the instance of the selected virtual instrument is selected and then the generate command within menu <b>73</b> of <figref idref="DRAWINGS">FIG. 3P</figref> is selected. The generate command of the instance command menu invokes a “generateSelectedInstrument” Generator class method which in turn calls a VirtualInstruments instance method “generate”. Selection of the generate command from menu <b>102</b> of <figref idref="DRAWINGS">FIG. 3I</figref> calls the “generate” method directly. The “generate” method produces the runMe code lines. These lines are then inserted into the runMe code listing for the generator being synthesized just above a selected existing code line. The “generate” method calls a “nextQuad” Virtual instruments class method which returns the number to be appended to the “q” output variable for the code. “Generate” also adds the new “q” variable to the bind list.

The command menu <b>106</b> of <figref idref="DRAWINGS">FIG. 3J</figref> is opened by invoking a “bindMenu” Generator instance method and the code command menu <b>73</b> of <figref idref="DRAWINGS">FIG. 3P</figref> is opened by calling a “codeMenu” Generator instance method. When the operator selects a line of runMe code in region <b>86</b> of the synthesizing window, and a parameter on the bind list in region <b>88</b>, and then selects the modify command on the bind command menu, or the modify code command on the code menu, a “modifyCode” method is called. The “modifyCode” method changes the quantity to right of the colon on the selected code line to reference the selected bind list variable. The delete command on the bind menu <b>106</b> of <figref idref="DRAWINGS">FIG. 3J</figref> initiates a “deleteBind” method which removes a selected parameter from the bind list while a clear command on the bind menu calls a “clearBindList” method to remove all parameters from the bind list. An inspect command on the bind menu invokes an “inspectBindList” menu which in turn calls the system inspect methods to permit the operator to inspect the bind list.

The operator can more directly edit the runMe code lines in synthesizing window region <b>86</b> by using other code menu commands. These additional code commands and methods permit an operator skilled in programming to develop virtual instrument primitives for carrying out functions not implemented by existing virtual instruments. A delete command invokes a “deleteCode” method which removes a selected line from the code list. An edit command calls an “editCode” method which opens a dialog window similar to window <b>110</b> of <figref idref="DRAWINGS">FIG. 3M</figref> containing a selected line of code. An inspect code command invokes the system inspect method through an “inspectCode” method, thereby permitting the operator to inspect the code list. An add code command uses an “addCode” method which opens a dialog window permitting the operator to type in a new code line. The “addCode” method in turn calls an “insertCode:” method which inserts the dialog window code line into the code list just above a selected line, or at the end if no line is selected. A reset code command calls a “resetCode” method which returns the runMe code to its initial state, thereby removing all but the first four and last runMe code lines. A clear command invokes a “clearCode” menu which deletes every line from the code list. The operator selects a compile message command when the code list is complete and this command calls a “compileMessage” method which concentrates the runMe code list to a character string and sends it to the system compiler.

The following ParameterBlok instance methods return the value of the parameter attribute indicated by the method name: “in”, “name”, “out”, “type”, “value”, and “view”. The following ParameterBlok methods are invoked to set the value of the parameter attribute indicated by the method name: “in:”, “name:”, “out:”, “type:”, “value:”, and “view:”. A ParameterBlok class method “new” is used to create a new parameter block.

In addition to Generator methods discussed above, the Generator class instance methods include additional instance methods employed by the methods described above. The methods “sB”, “sC” and “sP” return the currently selected binding parameter on the bind list, the currently selected line of code from the runMe list and the currently selected parameter on the parameter list, respectively. The “sType” and “sView” methods return the currently selected parameter and meter types highlighted in the synthesizer window. A “getBindList” instance method returns the current bind list and an “InstrumentList” class method returns the current instrument list. The class and instance methods “typeList”, “viewList”, “bindList”, “listInstruments” and “parameterList” sort and return the lists suggested by their names. The Generator instance method “codeList” and class method “codeList” both return the runMe code for a selected generator. A “selectedInstrument” method returns the name of an instrument currently selected on the instrument list, while a “selectedSynthesizer” method returns the name of the generator being synthesized. A “setName” method is employed to set an instance variable “instrumentName” to the name of the currently selected instrument while an “instrumentName” method returns the value of the variable. A “selectedBinding” method returns a currently selected line on the bind list. The following methods are utilized when selecting an item from a list: “wakeInstruments:” (when selecting an instrument from the instrument list), “wakeType:” (when selecting a parameter type from the parameter type list of the synthesizing window), “wakeBind”: (when selecting a line on the bind list), and “wakeView:” (when selecting a meter from the meter list of the synthesizing window). The class methods “initCode”, “initType”, and “initView” return the runMe code line, parameter type and meter type currently highlighted in the synthesizing window.

The VirtualInstruments class includes instance methods for providing common display messages for the virtual instrument classes created by the generators. In the preferred embodiment of the present invention three types of displays are possible: bargraph, panel meter, and a “list meter”. A list meter displays a list of operating mode options for the virtual instrument having more than one operating mode and the operator may select an operating mode from such a list. For instance, a signal generator virtual instrument may include a list meter allowing the operator to select between squarewave, sinewave,,or trianglewave signal generator outputs. A list meter is thus a form of menu and is created by invoking a “listMeter:” method. When the operator accesses the list meter menu a “listMeterMenu:” method is involved which responds to the operators selections. A “parameterMeter” method is invoked to display a bargraph or panel meter and a “display” method is used to update the display of a meter when a virtual instrument parameter value is changed. The method “myParameters:” assigns a current parameter block to an instance variable, wherein “myParameters” indicates the current input parameter values for the instrument. A “myValue:” method sets the value of a “myValue” instance variable, indicating the value of the virtual instrument output variable while a “myValue” method returns the value of the variable. In addition to the “new” method, the VirtualInstruments class methods include “classKounterIncrement” which returns the value of the number to be appended to the generator name when creating the name for a new virtual instrument instance, “nextQuad” (discussed hereinabove) which returns the number to be appended to the next “q” output variable of a line of synthesized runMe code, “resetQuad” which initializes a counter used by the “nextQuad” method, and “zeroKounter” which initializes a counter used by the “classKounterIncrement” method.

Appendix III also found in U.S. Pat. No. 4,849,880 contains a listing of a new Smalltalk system category “Interface-Meters”, according to the present invention. The InterfaceMeters category includes a new “MeterView” subclass of the existing Smalltalk “View” class for controlling the display of the meters on the virtual frontpanels associated with each virtual instrument, a new “MeterController” subclass of the existing Smalltalk “MouseMenuController” class for monitoring the cursor position and mouse button operation, and a new “MeterScale” subclass of the existing Smalltalk “Object” class for performing various calculations required by the MeterView when adjusting the display of a meter.

<figref idref="DRAWINGS">FIG. 5A</figref> lists the instance method names for the meter controller class. When the operator moves the cursor over a virtual instrument front panel meter displayed on the screen he may invoke a meter command menu such as <b>102</b> of <figref idref="DRAWINGS">FIG. 3I</figref> by operating the yellow mouse button. The operator may also invoke the window view command menu <b>112</b> of <figref idref="DRAWINGS">FIG. 3N</figref> by operating the blue mouse button and may change the value of the parameter displayed by using the red mouse button. The MeterController subclass methods monitor mouse button operation and cursor movement when the cursor is within the boundaries of a meter portion of a virtual front panel displayed on the screen. These methods send messages to the MeterView subclass indicating the position of the cursor and mouse button operations. The MeterView subclass uses information contained in these messages to adjust meter parameter values. When the cursor is in a meter window, the operator may adjust the meter reading by positioning the cursor over the meter pointer area (on a panel meter) or over the meter bar area (on a bargraph meter), depressing the red button on the mouse and then “dragging” the pointer or the bar to the desired position on the meter.

The MeterController subclass methods send messages to the MeterView subclass indicating the cursor position and mouse button operations. The MeterView subclass uses information contained in these messages to control the meter display. In the MeterController subclass, the “controlActivity” method determines when the operator has pressed the red mouse button, determines the position of the cursor, and then sends cursor position information to an instance of the MeterView subclass. An “isControlActive” method determines if the meter controller has control and gives precedence to the blue mouse button which opens the view command menu <b>112</b> window of <figref idref="DRAWINGS">FIG. 3N</figref>. A “newValueSymbol:” method sets an instance variable (newValueSymbol) to indicate the name of the method of the view to be invoked to send the view the mouse cursor position, while a “newValueSymbol” method returns the value of this variable. A “menuMessageReceiver” method returns the virtual instrument to which this virtual front panel corresponds. A “redButtonMenu:redButtonMessages:” method returns an error message if an attempt is made to set up a menu for the red button, since that button is used to set a graph or a meter.

The method structure of the object subclass MeterScale is depicted in <figref idref="DRAWINGS">FIG. 5B</figref>. Meterscale instance methods calculate the position of a panel meter pointer or the bar on a bargraph meter. A meterScale subclass “LinScale” includes methods for calculating a pointer or bar position on a linear scale while another meterScale subclass “LogScale” includes methods for calculating a pointer or bar position on logarithmic scale. The displacement of an indicating pointer or bar along a meter scale is referenced as a “Scale” number while the magnitude of the parameter is referenced as a “Value” number. The MeterScale subclass includes a “scaleToValue:” method, a “valueToScale:” method, and a “resetConstant” method which all return a message indicating that these methods are a subclass responsibility. A “maxScale” method returns the value of the upper limit of a meter scale displacement while a “maxScale:” method sets the upper limit of the Scale number. Similarly, a “maxValue” and a “MaxValue:” method return and set the value of the corresponding upper Value number limit. The “minScale”, “minScale:”, “minValue”, and “minValue:” methods are provided to return and set the lower limits for the Value and Scale numbers.

The LinScale subclass of MeterScale instance methods includes a “scaleToValue:” method for returning the magnitude of a Value number corresponding a selected Scale number and a “valueToScale:” method for returning the magnitude of a Scale number corresponding to a selected Value number. A “conversionConstant” method returns a value of a conversion constant used by the “scaleToValue:” method and “valueToScale:” method. A “resetConstant” method is called to initially set the conversion constant to nil and the conversion constant is recalculated whenever the maximum or minimum value changes (e.g., when a value exceeds the maximum). The LogScale subclass of MeterScale has “conversionConstant”, “resetConstant”, “scaleToValue:” and “valueToScale:” instance methods which carry out functions similar to those of similarly named LinScale subclass methods but which are adapted to provide the proper conversions for logarithmic scales. The LogScale subclass also includes “maxValue:” and “minValue:” instance methods for setting the maximum and minimum parameter values. The methods override the similarly named methods in the MeterScale subclass.

The method structure of the MeterView class is depicted in <figref idref="DRAWINGS">FIG. 5C</figref>. Each instance of a MeterView subclass controls the display of a virtual instrument front panel meter. An “initialize” method, called when a meter is initially created, associates the meter with the current Smalltalk project, selects a pen to be used for drawing the meter, and then calls a “forceFullDisplayNextTime” method which wipes out any data in an image cache. Thus, when the meter is subsequently drawn onto the screen the meter display must be reconstructed from the meter model and not from the cache. (A saved image of the meter face is used in preference to drawing the meter afresh whenever possible, for reasons of efficiency.) An “itemName:” method sets parameters for display of the meter name. A “maxValue” method and a “maxValue:” method return and set the maximum value of the parameter to be displayed on a meter while a “minValue” method and a “minvalue:” method return and set the minimum value of a number to be displayed. A “scale” method and a “scale:” method return and set the scale of the meter.

A “display” method of the MeterView subclass is called to initiate the display of a meter. As discussed hereinabove, each parameter of each virtual instrument is associated with two parameter methods, one for returning the value of the parameter and one for setting the value of the parameter. A “valueAccessSymbol:” method sets a variable “valueAccess” to the name of a virtual instrument parameter method to return the value of the parameter. A “valueFromModel” method is called to invoke the parameter method of the virtual instrument to return the value of a parameter. The “valueFromModel” method tests for the need to extend, and extends if needed, the limits of the number which may be displayed by the meter when the value returned exceeds the current range of the meter. A “valueChangeSymbol:” method sets a “valueChange” variable to the name of the virtual instrument parameter method for setting the value of the parameter and a “valueChange” method sends a message to the virtual instrument invoking that parameter method thereby setting the parameter to a new value. When parameter values in a virtual instrument change, a single update message containing the “updateOn” variable as its argument may be sent to each MeterView instance controlling each meter associated with the instrument thereby updating each meter display. An “update:” method updates the meter display either based on the last known value of the parameter or by acquiring a new value from the virtual instrument depending on whether the “selfOrSymbol” argument references the meterview or is equal to an “updateOn” variable. An “updateSymbol:” procedure sets the “updateOn” variable.

A single MeterView class procedure, “withScale:”, is called to create a new instance of a meter with a scale (either linear or logarithmic) specified by the argument. In order to display the value of a parameter on a meter, it is necessary to convert that value to an equivalent position on the meter. In the case of a bargraph meter the equivalent position is found in terms of horizontal displacement between the maximum and minimum scale positions while in the case of a panel meter the equivalent position is found in terms of an angular displacement along the meter. In the “BarGraphView” subclass of MeterView a “displayView” instance procedure provides the detailed instructions for drawing a bar graph meter and makes use of the appropriate MeterScale procedures to convert parameter values into equivalent meter position. A “newValue:” method changes the parameter value displayed on a meter in response to a message from the meter controller indicating the location of the cursor on the meter when the operator is using the red mouse button to change the meter reading. An “initScale” method is provided to set the initial value of the scale minimum when the meter is initially created.

The PanelMeterView subclass of MeterView includes a “displayView” instance method including instructions for drawing a panel meter and an “initScale” instance method which initially sets the minimum and maximum scale positions to −90 degrees and +90 degrees, respectively, thereby specifying a 180 degree full range scale. A “newValue:” instance method sets the current value of a displayed parameter to the value indicated by the current cursor position on the meter when the operator is using the red button to set the parameter value.

Once a virtual instrument class is synthesized according to the method described hereinabove the operator may create instances of the class which may be independently run to instruct the computer to perform a selected sequence of operations. In addition to utilizing a virtual instrument instance as an independent means to control computer operation, the operator may also utilize an instance of a synthesized virtual instrument for synthesizing other virtual instruments. For example, several instances of the synthesized gainmeter described hereinabove may be incorporated into a synthesized “frequency-response” virtual instrument for measuring the frequency response of an amplifier wherein each instance of the gainmeter is utilized to measure amplifier gain at a different frequency. The measuredGain outputs of each gainmeter may then be displayed on a group of contiguous bargraph meters to form a frequency response curve.

Therefore, the present invention provides a means for an operator to program a computer in a structured fashion by synthesizing a hierarchy of virtual machines with each successive virtual machine incorporating the functions of previously synthesized machines. The invention thus permits an operator not skilled in computer programming to create a virtual machine for performing a complex set of operations by first synthesizing and testing a set of less complex virtual machines for carrying out portions of the complex set of operations and then synthesizing the complex virtual machine based on the less complex machines.

While the preferred embodiment of the present invention described hereinabove is adapted to produce software for use in conjunction with a computer-based instrument system, the present invention may be adapted to produce software for other applications including, but not limited to, instrumentation control and data processing applications. Therefore, while a preferred embodiment of the present invention has been shown and described, it will be apparent to those skilled in the art that many changes and modifications may be made without departing from the invention in its broader aspects. The appended claims are consequently intended to cover all such changes and modifications as fall within the true spirit and scope of the invention.