|Publication number||USRE42579 E1|
|Application number||US 11/443,553|
|Publication date||Jul 26, 2011|
|Filing date||May 30, 2006|
|Priority date||Nov 18, 1985|
|Also published as||US4849880, US5479643|
|Publication number||11443553, 443553, US RE42579 E1, US RE42579E1, US-E1-RE42579, USRE42579 E1, USRE42579E1|
|Inventors||Kasi S. Bhaskar, James K. Peckol|
|Original Assignee||National Instruments Corporation|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (32), Non-Patent Citations (52), Referenced by (2), Classifications (17)|
|External Links: USPTO, USPTO Assignment, Espacenet|
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.
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.
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.
According to the present invention, the host computer 22 is adapted to communicate with each instrument 12 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 26. 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 24.
Signal generator 14 suitably produces a sinewave signal having two variables, frequency and amplitude, as controlled by data provided by the host computer 12 via bus 24. Referring to
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 22. For convenience, these virtual machines may also be referred to as virtual instruments. Referring to
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
where V2 is the output voltage of the amplifier measured by the voltmeter and V1 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 V1, a voltmeter virtual instrument to produce V2, a divider virtual instrument (machine) to compute the ratio of V2 to V1, a logarithm virtual instrument (machine) to find the log to the constant base of the output (V2/V1) of the divider virtual instrument, and a multiplier virtual instrument (machine) to find the product of a constant (20) and the output Log10(V2/V1) of the logarithm virtual instrument.
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 22 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
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 26 to move a cursor over the name of the class, such as “Divider” in the generator list 70, and presses and releases the red mouse button to select the “Divider” name. Then the yellow button is depressed causing a first command menu 74, as shown in
In a similar manner, the operator uses the cursor and the first command menu 74 of
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 74 of
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 70 of
An end product of the synthesizing process is a Smalltalk listing, displayed within region 86, 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
|q5 q4 q3 q2 q1 t| 
“1 October 1985” 
t ←(Generator InstrumentList) at: ‘aSignalGenerator15’. 
t frequency: (self atFreq). 
t amplitude: (self inLevel). 
q1 ←t runMe. 
t ←(Generator InstrumentList) at: ‘aVoltmeter16’. 
q2 ←t runMe. 
t ←(Generator InstrumentList) at: ‘aDivider12’. 
t denominator: (self inLevel). 
t numerator: (q2). 
q3 ←t runMe. 
t ←(Generator InstrumentList) at: ‘aLogarithm13’. 
t number: (q3). 
t base: 10. 
q4 ←t runMe. 
t ←(Generator InstmmentList) at: ‘aMultiplier14’. 
t left: 20. 
t right: (q4). 
q5 ←t runMe. 
^ self measuredGain: q5 “Replace Me” 
Line  is the title of the method, runMe. Line  declares q5, q4, q3, q2, q1 and t as temporary variables. Line  is a comment identifying the runMe method as being associated with the Gainmeter and line  is a comment indicating the date when the runMe method was created. In line  the variable t is made to reference the aSignalGenerator15 object on the Generator InstrumentList. In other words, when the variable t is then used to designate an object, the designated object is the aSignalGenerator15 virtual instrument. In line  a message is sent to the aSignalGenerator15 virtual instrument which assigns the value of the Gainmeter (referenced by the word “self”) input parameter atFreq to the frequency input parameter of aSignalGenerator15. In line  a message is sent to the aSignalGenerator15 object which assigns the value of the gainmeter input parameter inLevel to the amplitude input parameter of aSignalGenerator15. In line  a “runMe” message is sent to the aSignalGenerator15 virtual instrument which causes it to set the frequency and amplitude controls of the signal generator 14 of
In line  the t variable is reassigned to reference the aVoltmeter16 virtual instrument on the generator instrument list and in line  a runMe message is sent to the aVoltmeter16 virtual instrument causing it to acquire the output voltage measured by the voltmeter 16 of
In line  the variable t is reassigned to reference the aDivider12 virtual instrument and in lines  and  messages are sent to aDivider12 causing it to assign the value of the inLevel gainmeter input parameter (V1 in equation [A] hereinabove) to the denominator parameter of aDivider12 and to assign the q2 variable (i.e., V2) of line  to the numerator parameter of aDivider12. In line  a runMe message is sent to aDivider12 causing it to divide the numerator parameter by the denominator parameter thereby producing an output quantity equal to V2/V1. Also in line  the aDivider12 output is assigned to another variable q3.
In line  the variable t is reassigned to reference the aLogarithm13 virtual instrument and in lines  and  messages are sent to aLogarithm13 causing it to assign the value of the q3 variable (V2/V1) to the number parameter of aLogarithm13 and to assign the constant 10 to the base parameter of aLogarithm13. In line  a runMe message is sent to aLogarithm13 causing it to produce an output quantity equal to the log to the base 10 of number (i.e., Log10(V2/V1)). This quantity is assigned to the variable q4.
In line  the variable t is reassigned to reference the aMultiplier14 virtual instrument and in lines  and  messages are sent to aMultiplier14 requesting it to assign the constant 20 to its left parameter and to assign the variable q4 produced in line 18 as its right parameter. In line  a runMe message is sent to aMultiplier14 causing it to produce an output quantity equal to the 20 times q4, i.e., 20Log10(V2/V1). This output quantity is assigned to the variable q5. Finally, in line , the measured gain of the device under test q5 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 86 of the synthesizing window 82 of
^ self myValue: self myValue “replace me” [23a]
This last line is a precursor to line  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 “q5” variable as described hereinbelow. The remaining lines - are also inserted into the listing during the synthesizing process.
Referring again to the synthesizing window 82 of
The operator may define an input or output parameter for the synthesized instrument by adding it to the parameter list in subregion 90. First the cursor is moved over the subregion and a yellow mouse button is pressed to open a second command menu window 100 as illustrated in
Each time the operator adds an input or an output parameter to the parameter list of subregion 90, a line is added to region 88 listing the parameter. As shown in
At this point the operator has defined the virtual front panel for the gaimneter, as illustrated in
First, the operator selects the first virtual instrument to be utilized by the gainmeter, aSignalGenerator15, by moving the cursor over the displayed virtual front panel for the aSignalGenerator15, illustrated in
Once operation of the virtual signal generator is verified (if such is desired), the code for “connecting” the virtual signal generator to the aGainmeter1 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 86 of the synthesizing window of
t ←(Generator InstrumentList) at: ‘a SignalGenerator15’. 
t frequency:1325. [6a]
t amplitude:5.59. [7a]
q1 ←t runMe. 
These lines are similar to lines - of the completed runMe listing except that in lines [6a] and [7a] 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  and  of the completed listing. At the same time lines , [6a], [7a], and  are added to the listing in region 86, the q1 variable produced in line  is added to the bind list in region 88, as well as to the temporary variable declarations in line 2.
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 [6a] of the listing in region 86 and the “self atFreq” line of the bind list in region 88 and then operates a yellow selection button on the mouse to open a fourth command menu window 106 as illustrated in
Next the operator selects the aVoltmeter 16 front panel 34 of
t ←(Generator InstrumentList) at:“aVoltmeter16”. 
q2 ←t runMe. 
At the same time these lines are inserted into the listing in region 86, the q2 variable is added to the bind list in region 88 and to the temporary variables in line 2 of region 86.
In similar fashion the following lines are added to the listing in region 86 when the operator selects the aDivider12 instrument and the generate command of the command menu 102 of
t ←(Generator InstrumentList) at: “aDivider12”. 
t denominator: 1. [12a]
t numerator: 1. [13a]
q3 ←t runMe. 
The q3 variable is also added to the bind list in region 88 of the synthesizing window 82 of
In a similar fashion, the operator may select and use the generate and modify code commands of the menu of
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 108 of
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
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 112 as illustrated in
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 (1) identifies the virtual instrument subclass “Adder” and line (2) defines three instance variables: left, output and right. Lines (3) and (4) indicate the VirtualInstruments class has no class variables and no pool dictionaries. Line (5) 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
Line (6) introduces the parameter methods and line (7) 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 (8) 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 (9), (10), (11) and (12) 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 (7) and (8) permit interrogation and setting of the left variable.
Lines (13)-(18) define the parameter method executed in response to a runMe method. Line (13) recites the runMe selector and lines (14) and (15) are comments indicating the class (Adder) and the date of creation of the class. Line (16) defines a temporary variable, t. In line (17) the value of the left parameter and the value or the right parameter are obtained by using the left and right methods of lines (7) and (11). 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 17 also invokes the “output:” method to set the output parameter on the virtual front panel of an adder.
Line (19) introduces the setValues methods, the first of which is defined in line (20) 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 (21) and (22) are similar to the method of line 20 except that line (21) relates to the setting of the output parameter and line (22) 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 (7) and (8) and a setValues method similar to that of line (20) 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
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 70 illustrated in
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 74 of
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 73 as illustrated in
When a virtual front panel is displayed, the operator may open the meter menu 102 of
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 74 of
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 82 of
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 84 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 84 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 100 of
As part of the synthesizing process, the operator may insert new lines into the runMe listing in region 86 of the synthesizing window 82 of
The command menu 106 of
The operator can more directly edit the runMe code lines in synthesizing window region 86 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 110 of
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.
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 112 window of
The method structure of the object subclass MeterScale is depicted in
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
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.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US4064394||May 28, 1975||Dec 20, 1977||American Chain & Cable Company, Inc.||Electronic digital process controller having simulated analog control functions|
|US4152760||Sep 16, 1977||May 1, 1979||The Foxboro Company||Industrial process control system|
|US4245318||May 7, 1979||Jan 13, 1981||General Electric Company||Circuit breaker demonstrator and distribution circuit protection coordinator apparatus|
|US4298955||Mar 23, 1977||Nov 3, 1981||The Insurance Technical Bureau||Method of and apparatus for the detection and analysis of hazards|
|US4315315 *||Mar 9, 1971||Feb 9, 1982||The Johns Hopkins University||Graphical automatic programming|
|US4455619 *||May 29, 1981||Jun 19, 1984||Hitachi, Ltd.||Interactive equipment for computer programming by linkage of labeled block representations of arithmetic/logical subprograms|
|US4497033||Sep 22, 1982||Jan 29, 1985||Process Technologies, Inc.||Multiplexed arrangement for connecting a plurality of transducers to a field interface device at a storage tank|
|US4499549||Jun 25, 1982||Feb 12, 1985||Automation Systems, Inc.||Digital computer having analog signal circuitry|
|US4546435||Jun 20, 1984||Oct 8, 1985||Herbert Frank P||Graphic computer system and keyboard|
|US4570217||Mar 28, 1983||Feb 11, 1986||Allen Bruce S||Man machine interface|
|US4586035||Feb 29, 1984||Apr 29, 1986||International Business Machines Corporation||Display terminal with a cursor responsive virtual distributed menu|
|US4628444||Sep 30, 1983||Dec 9, 1986||Fanuc Ltd||Operating information input method in numerical control apparatus|
|US4635183||Nov 21, 1983||Jan 6, 1987||Fanuc Limited||Control unit provided with status display|
|US4636934||May 21, 1984||Jan 13, 1987||Otis Engineering Corporation||Well valve control system|
|US4642790||Mar 14, 1984||Feb 10, 1987||International Business Machines Corporation||Presentation space management and viewporting on a multifunction virtual terminal|
|US4656603 *||Mar 1, 1984||Apr 7, 1987||The Cadware Group, Ltd.||Schematic diagram generating system using library of general purpose interactively selectable graphic primitives to create special applications icons|
|US4663704 *||Dec 3, 1984||May 5, 1987||Westinghouse Electric Corp.||Universal process control device and method for developing a process control loop program|
|US4674053||Sep 11, 1986||Jun 16, 1987||Toshiba Kikai Kabushiki Kaisha||Control system of injection molding machines|
|US4677587||May 14, 1985||Jun 30, 1987||Sanders Associates, Inc.||Program simulation system including means for ensuring interactive enforcement of constraints|
|US4679137 *||Apr 30, 1985||Jul 7, 1987||Prometrix Corporation||Process control interface system for designer and operator|
|US4688167||Sep 27, 1984||Aug 18, 1987||Wang Laboratories, Inc.||Screen manager for data processing system|
|US4695968||Feb 2, 1984||Sep 22, 1987||Prime Computer, Inc.||Digital system simulation method and apparatus having improved sampling|
|US4736340 *||Jul 25, 1984||Apr 5, 1988||La Telemecanique Electrique||Processor generating control programs for a programmable controller|
|US4745543||May 28, 1987||May 17, 1988||Fischer & Porter Co.||Front panel for a process controller|
|US4811205||Jun 24, 1985||Mar 7, 1989||International Business Machines Corporation||Pipeline display control apparatus with logic for blocking graphics processor accesses to shared memory during selected main processor graphics operations|
|US4813013 *||Dec 22, 1986||Mar 14, 1989||The Cadware Group, Ltd.||Schematic diagram generating system using library of general purpose interactively selectable graphic primitives to create special applications icons|
|US4816988||Aug 3, 1982||Mar 28, 1989||Mitsubishi Denki Kabushiki Kaisha||Master station apparatus in supervisory and control system|
|US4868785 *||Jan 27, 1987||Sep 19, 1989||Tektronix, Inc.||Block diagram editor system and method for controlling electronic instruments|
|US4901221 *||Apr 14, 1986||Feb 13, 1990||National Instruments, Inc.||Graphical system for modelling a process and associated method|
|US4914568 *||Oct 24, 1986||Apr 3, 1990||National Instruments, Inc.||Graphical system for modelling a process and associated method|
|US4967381 *||Jul 6, 1989||Oct 30, 1990||Prometrix Corporation||Process control interface system for managing measurement data|
|US5301336 *||Jul 12, 1989||Apr 5, 1994||National Instruments, Inc.||Graphical method for programming a virtual instrument|
|1||"Activelmages Package-The First KEE System PowerPak"; IntelliCorp, 1984; 4 pages.|
|2||"Control and Instrumentation Magazine"; Feb. 1984; 4 pages.|
|3||"Preliminary Modvue Applications Design Guide"; 1982; 80 pages.|
|4||"Supersmart Equipment-Software for Computer-Based Instruments Brings Users a Plethora of Benefits"; IEEE Spectrum, Jan. 1983; 5 pages.|
|5||"The Knowledge Engineering Environment-An IntelliCorp Technical Article"; 1984; 26 pages.|
|6||"Activelmages Package—The First KEE System PowerPak"; IntelliCorp, 1984; 4 pages.|
|7||"Supersmart Equipment—Software for Computer-Based Instruments Brings Users a Plethora of Benefits"; IEEE Spectrum, Jan. 1983; 5 pages.|
|8||"The Knowledge Engineering Environment—An IntelliCorp Technical Article"; 1984; 26 pages.|
|9||Alan Boring; "ThingLab-A Constraint-Oriented Simulation Laboratory"; Xerox; Jul. 1979; 107 pages.|
|10||Alan Boring; "ThingLab—A Constraint-Oriented Simulation Laboratory"; Xerox; Jul. 1979; 107 pages.|
|11||Alan Borning; "The Programming Language Aspects of ThingLab, a Constraint-Oriented Simulation Laboratory"; Xerox Palo Alto Research Center; ACM Oct. 1981; 70 pages.|
|12||Albert Stevens, Bruce Roberts, and Larry Stead; "The Use of a Sophisticated Graphics Interface in Computer-Assisted Instruction"; IEEE CH&A, Mar./Apr. 1983; 12 pages.|
|13||Answer to Third Amended Complaint; SoftWIRE Technology, LLC and Measurement Computing Corporation vs. National Instruments Corportion (Civil Action No. 03-10107REK); Nov. 21, 2003; 14 pages.|
|14||Aragam R. Nagesh, Richard S. Shirley and Maureen E. Gordon; Rapid Prototyping for the Human/ Process Interface; ISA Advances in Instrumentation, Oct. 22-25, 1984; 14 pages.|
|15||Arnold Miller; "The Programmable Controller Based Distributed Control System"; ISA Advanced in Instrumentation, Oct. 22-25, 1984; 15 pages.|
|16||*||Bhaskar, K.S. et al., "Virtual Instruments: Object-Oriented Program Synthesis," Proceedings of the Conference on Object-Oriented Programming Systems, Languages and Applications, Sep. 1986, pp. 303-314.|
|17||Brad A. Myers; "Visual Programming, Programming by Example, and Program Visualization: A Taxonomy"; Dynamic Graphics Project at University of Toronto, Apr. 1986; 8 pages.|
|18||Carla M. Wong and Richard W. Crawford; "Application of Artificial Intelligence to Triple Quadrupole Mass Spectrometry (TQMS)"; Institute of Electrical and Electronics Engineers; Oct. 1983; 11 pages.|
|19||Carla M. Wong; "Expert Systems for the Laboratory: Triple Quadrupole Mass Spectrometry (TQMS) (A Capsule Report on 'Expert System' for A/C Interface)"; Mar. 1984; 13 pages.|
|20||Carla M. Wong; "Expert Systems for the Laboratory: Triple Quadrupole Mass Spectrometry (TQMS) (A Capsule Report on ‘Expert System’ for A/C Interface)"; Mar. 1984; 13 pages.|
|21||Carla M. Wong; Expert Systems Technology Applied to Instrument Operation and Data Acquisition of a Triple Quadrupole Mass Spectrometer (TQMS); National Computer Conference at Las Vegas, Nevada; Jul. 9-12, 1984; 60 pages.|
|22||D. Dustin Henderson, Jr.; The Trillium User Interface Design Environment; Intelligent Systems Laboratory Xerox Palo Alto Research Center; CHI'86 Proceedings, 1986; 7 pages.|
|23||Daniel G. Bobrow and Mark Stefik; "The Loops Manual (Preliminary Version)"; Xerox Corporation, 1983; 128 pages.|
|24||David Canfield Smith; "Pygmalion: A Creative Programming Environment"; Dissertation Presented to Stanford University; May 1975; 244 pages.|
|25||Defendant National Instruments' Second Supplemental Responses to Plaintiff SoftWIRE Technology's Fourth Set of Interrogatories [Nos. 11-12]; SoftWIRE Technology, LLC and Measurement Computing Corporation vs. National Instruments Corporation (Civil Action No. 03-10107REK); Sep. 30, 2004; 68 pages.|
|26||Douglas R. Haroldsen; "Software Package Lets PC Control Instruments with a Touch"; Electronic Design, Oct. 31, 1984; 9 pages.|
|27||James D. Hollan, Edwin L. Hutchins, and Louis Weitzman; "Steamer: An Interactive Inspectable Simulation-Based Training System"; The AI Magazine, Summer 1984; 13 pages.|
|28||James Hollan, Albert Stevens, and Michael Williams; "Steamer: An Advanced Computer-Assisted Instruction System for Propulsion Engineering"; 1980; 5 pages.|
|29||James Hollan, Edwin Hutchins, Mark Rosenstein, and Louis Weitzman; "Tools for Graphical Interface Design"; Proceedings of a Symposium Sponsored by the Metropolitan Chapter of the Human Factors Society, Nov. 15, 1984; 17 pages.|
|30||John L. Hedrick and Evan L. Pageler; "Effective Operation System Characterization with an Interactive Colorgraphics Operator Console"; Fisher Controls Company, ISA Advances in Instrumentation, Oct. 20-23, 1980; 14 pages.|
|31||Kazuo Yano, Tadashi Nishijima, Katsuhisa Yamaguchi; and Ichiro Akasaki; "Microcomputer-Based Programmable Controller Systems for Industrial Application"; Toshiba Corporation; IEEE 1983; 7 pages.|
|32||Kenneth D. Forbus; "An Interactive Laboratory for Teaching Control System Concepts"; Report No. 5511, Jan. 1984; 41 pages.|
|33||Mark Stefik and Daniel G. Bobrow; "Object-Oriented Programming: Themes and Variations"; Intelligent Systems Laboratory; The Al Magazine, 1984; 23 pages.|
|34||Mark Stefik, Daniel G. Bobrow, Sanjay Mittal, and Lynn Conway; "Knowledge Programming in Loops: Report on an Experimental Course"; The AI Magazine, Fall 1983; 22 pages.|
|35||Michael A. Catalano and Michael J. Charland; "The Use of Touchsensitive Video Displays in on Line Control Systems"; Canberra Industries, Meriden, CT, IECON 1983; 7 pages.|
|36||Michael D. Williams, James D. Hollan, and Albert L. Stevens; "Human Reasoning About a Simple Physical System"; Chapter 7; 1981; 23 pages.|
|37||Michael N. Granieri, William Keefe, and Thomas McNamee; "An Approach to an Open-Architecture Functional Testing System"; IEEE; 1984; 8 pages.|
|38||Michael Williams, James Hollan, and Albert Stevens; "An Overview of Steamer: An Advanced Computer-Assisted Instruction System for Propulsion Engineering"; Psychonomic Society, 1981; 6 pages.|
|39||PCIL. Process Control and Instrumentation Ltd., formed in 1981, articles dated 1984; 8 pages.|
|40||Richard Fikes and Tom Kehler; "The Role of Frame-Based Representation in Reasoning"; Communications of the ACM, vol. 28, No. 9, Sep. 1985; 17 pages.|
|41||Robert V. Rubin; "Language Constructs for Programming by Example"; Department of Computer Science, Brown University, 1986; 12 pages.|
|42||Shin-Ichi Takigishi, Hiroshi Yamada, and Harry Wilson; "User-Oriented Flexible Operator Station for Distributed Process Control Systems"; ISA Advances in Instrumentation, Oct. 22-25, 1984; 14 pages.|
|43||Steven K. Gregory; "Interactive Television for Control Systems"; ISA Advances in Instrumentation, Oct. 20-23, 1980; 11 pages.|
|44||Stipulated Dismissal with Prejudice; SoftWIRE Technology, LLC and Measurement Computing Corporation vs. National Instruments Corporation (Civil Action No. 03-10107REK); Apr. 29, 2005; 5 pages.|
|45||T.K. Barnaby; "An Exploration of the Virtual Instrumentation Concept"; Thesis Presented to the University of Wales; Nov. 1983; 227 pages.|
|46||Terry Kenneth Barnaby; "The Virtual Instrument Workstation"; Thesis Presented to the University of Wales; Dec. 1987; 307 pages.|
|47||Third Amended Compliant: SoftWIRE Technology, LLC and Measurement Computing Corporation vs. National Instruments Corporation (Civil Action No. 03-10107REK); Nov. 6, 2003; 11 pages.|
|48||Thomas P. Kohler; An Application Development System for Expert Systems; Intelligentics, Systems, and Software, Jan. 1984; 17 pages.|
|49||Thomas S. McNamee and John J. Woodfine; "Instrument-Based Test Generation a Cost-Effective Program Development Tool"; ManTech International Corporation; 1983; 5 pages.|
|50||Timothy J. Miller; "Bit-Mapped Graphics Editor Simplifies High Resolution Display Building"; Control Engineering; Apr. 1984; 2 pages.|
|51||W. Buxton, M.R. Lamb, D. Sherman, and K.C. Smith; "Towards a Comprehensive User Interface Management System"; Computer Graphics, vol. 17, No. 3; Jul. 1983; 8 pages.|
|52||William F. Finzer and Laura Gould; "Programming by Rehearsal"; Byte, Jul. 1984; 17 pages.|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US8683004 *||Dec 29, 2009||Mar 25, 2014||Trumpf Werkzeugmaschinen Gmbh + Co. Kg||Apparatus for controlling a machine|
|US20100154051 *||Dec 29, 2009||Jun 17, 2010||Trumpf Werkzeugmaschinen Gmbh + Co. Kg||Apparatus for controlling a machine|
|U.S. Classification||717/109, 717/105, 717/124, 715/771, 700/17, 717/107, 717/113, 700/83, 715/859|
|International Classification||G05B15/00, G06F3/048, G06F9/44|
|Cooperative Classification||G06F8/34, Y10S715/97, G06F9/4443|
|European Classification||G06F9/44W, G06F8/34|