Block diagram system and method for controlling electronic instruments with simulated graphic display
This is a continuation of application Ser. No. 07/007,234 filed Jan. 27, 1987 and issued of Sept. 19, 1989 as U.S. Pat. No. 4,868,785. 
    
    
     RELATED APPLICATION DATA 
     This application is related to commonly-assigned U.S. patent application Ser. No. 935,369, filed on even date herewith by D. Stubbs, entitled SIGNAL VIEWING INSTRUMENTATION CONTROL SYSTEM now U.S. Pat. No. 4,812,996. 
     BACKGROUND OF THE INVENTION 
     The invention relates generally to a graphical user interface system and more particularly to a system and method for a user interactively to computer-control an electronic testing system. 
     In a typical experiment or testing environment, there is a device or object under test, a means to stimulate the device under test, and a means to measure the response of the device to stimulation. The process of stimulus/response testing is typically followed by an analysis phase to extract specific information from the response measurement. 
     In a computer-based instrument environment, a host computer is connected to the stimulus and response instruments. This computer, commonly called the controller, controls the operation of the test instruments and can be used to perform the analysis of the response data. The most common interface for connecting the controller to the instruments is the GPIB (General Purpose Interface Buss) or IEEE 488 standard. 
     The most common approach to control of this computer-based stimulus/response testing has been to write a program in BASIC, FORTRAN or other high-level programming language to control the instrumentation and, in a similar manner, to write a program to perform the response data analysis. The instrument control programs conventionally include subroutines, or drivers, which interpret the control expressions in the high-level language and convert them into the communication protocol required to control the instrument. For certain instruments, drivers may also report the state of the instrument, such as the control settings and error status information, as well as the response data that an instrument may detect. These drivers are essentially similar to the computer operating systems used to communicate with peripheral devices, such as terminals, disk drives and magnetic tape drives. 
     BASIC is typically the language of choice for test system developers and users, because it is easy to learn by novices and is interactive. Nevertheless, the writing of control and analysis programs can become quite tedious and the programs are often difficult to modify. The user must communicate with the test instrumentation in terms of its conventional control settings, e.g. amount of vertical offset, vertical scale factor, etc. The user must understand not only how to control the test instrument but how to communicate the desired controls in the programming language. 
     Many high-level languages have also been extended to provide means for graphically displaying data returned from test instruments. The programs employ windowing modules or subroutines to convert acquired data, e.g., digitized signals, from the coordinate system of the data, e.g., time vs. voltage, into the coordinate system of the display device (CRT). With data transformed into display coordinates, graphing modules interpret various language commands and apply the commands to the display-coordinate data and produce instructions in a form that the display device requires to render a graphical representation of the test data. 
     High-level language elements, windowing modules and graphing modules have been widely used to produce graphical representations of data stored in computer memory. They have also been used in conjunction with graphic input devices, e.g., a joystick, mouse, etc, which controls a display cursor, to interpret the cursor&#39;s screen location in terms of the coordinate system of the display data. This type of display system enables the user to display the stored data in different scales, but the resolution of the data displayed is limited to that which is stored. Zooming in on a portion of a waveform cannot add any more detail about the waveform than was originally stored. Also, the stored data is limited to the record length of data stored. Thus, zooming out beyond the dimensions of the stored data does not make more data available. To remedy both of these problems requires the user to reprogram the test instrument to acquire a new set of data. 
     In conventional manual operation of test instruments, the user operates the test instrument controls interactively in response to the graphical presentation of the data. The operation of programmable test instruments controlled by high-level programming languages, however, requires forethought and calculation. Thus, programmable test instruments are difficult to use in an interactive manner. The user can set goals in terms of the display data, but must transform these goals into terms of test instrument settings in order to act. If more than one instrument is being used, each must be set separately. Similarly, if the manner of analysis of the returned test data is to be modified, the analysis routines must also be reprogrammed. All of this entails much complexity, and requires substantial expertise, time and careful work to accomplish successfully. 
     Software systems are also known which enable a user to model and simulate systems on a computer and interactive display. An example of such a system is BLOSIM, a general purpose simulation program for sampled data systems described in D. G.. Messerschmitt, &#34;Blosim--a Block Simulator,&#34; Dept. of Electrical Engineering, Univ. of California--Berkeley (June 7, 1982). A BLOSIM user partitions a system to be simulated into small pieces implementing elementary parts of the system, each piece called a block, and provides a simulation program for each block. The user also provides a program that defines the topology of interconnection of the blocks. BLOSIM then handles the details of the actual interconnection and execution of the blocks. BLOSIM was not designed to be used as a test instrument control program. Moreover, the topology of the blocks must be recompiled each time a change is made in the system under test. Additionally, application of BLOSIM to actual systems becomes very difficult as the topologies become increasingly complex. Hence, within the known state of the art, BLOSIM is not applicable to test instrumentation control. 
     Accordingly, a need remains for an improved method and apparatus for controlling test instrumentation and analyzing signals. 
     SUMMARY OF THE INVENTION 
     One object of the invention is to provide an improved method and means for controlling, through a computer workstation interface, a test instrumentation system. 
     A second object of the invention is to provide a single channel of access to engineering, testing, analysis, research, etc. resources in a test system. 
     Another object is to eliminate the need for test instrument front panel controls and displays by providing workstation-based control and thereby reduce the cost of programmable test instruments. 
     A further object is to minimize the time required for a user to establish or modify test instrument settings. 
     Yet another object is to enable a user to control a test system or to analyze signals in a manner to which the user is accustomed, including defining control or analysis in terms of operational goals. 
     An additional object is to enable a user to control the complexity of the user interface with test instrumentation systems and analysis problems. 
     The invention provides a method and apparatus for controlling a test instrumentation system, or usable in other applications such as signal analysis, that enables a user to manipulate operation through a graphical interface based on block diagrams. The system includes a programmable computer having a memory and a processor, a graphic display means, and user-operable input means for inputting data to the computer. Preferably, for controlling a physical system such as test instrumentation, the computer also includes an external communications means. The computer is programmed with software which enables the user interactively to edit and program a block diagram for execution by the computer. 
     So programmed, the processor is responsive to the user operable input means for producing graphic data for displaying graphic images, including one or a plurality of user selected blocks on the display means. The blocks preferably include a first type of block having at least one output terminal and a second type of block having at least one input terminal, and can include blocks having both input and output terminals. Associated with each of the first type of blocks is a function instruction means executable by the processor for generating a first set of signal data in accordance with a predefined first function and providing the signal data at the output terminal of such block. Similarly, associated with each of the second type of blocks is a function instruction means executable by the processor for transforming an input signal data in accordance with a predefined second function The second type of block can include means for returning information derived from the transformed data to the user. A third type of block has both input and output terminals. Such blocks have an associated function instruction means that is executable by the processor for transforming the input signal data in accordance with a predefined third function and providing a transformed set of signal data on the output terminal. 
     The system also includes means for representing data flow between blocks, preferably in the form of interconnection display means responsive to the user-operable means for displaying an interconnection between the various types of blocks, connected from an output terminal of one block to an input terminal of another block as designated by the user. Associated with the displayed interconnection is a data flow means for transmitting the signal data from output to input terminal between the function instruction means associated with each of the blocks between which the displayed interconnection is connected. 
     The system includes means responsive to the input means for actuating the processor to execute each of the function instruction means in turn. Accordingly, a first set of signal data is generated in accordance with the functions of each of the first type of blocks. This set of signal data is transmitted to the function instruction means of blocks of the second type in accordance with the data flow paths defined by the interconnections. The signal data generated by the blocks of the first type is then transformed in accordance with the functions of the second type of blocks to produce a second set of signal data. 
     The system can include means for actuating the graphical display means for graphically displaying the second set of signal data. Transforming-type blocks, having both input and output terminals, and their associated function instruction means, can be connected between blocks of the first and second type to perform intermediate transformations of the signal data. 
     Preferably, the system includes a block storage means for storing a plurality of unique function instruction means, each in association with a predetermined user-selectable block. A means is provided for the user to select, by operation of the user-operable means and block display means, the stored function instruction means associated with a designated block. A means is also provided that is responsive to the user interconnecting the blocks on the display means for assembling the function instruction means for each designated block for execution by the processor in a sequence determined by the direction of signal data transmission indicated by the interconnections. 
     Two or more blocks of the first type can be connected by interconnections to a block of the second type and the system includes means for executing the selected function instruction means for each of the first type of block and outputting resultants of the signal data from each such block to the second block in substantially parallel operation. Similarly, a block of the first type can be connected by interconnections to two or more blocks of the second type and the system includes means for executing the selected function instruction means for the blocks of the second type on the signal data transmitted by the data flow means for each interconnection from the first block. 
     Many different kinds of blocks can be used in the system, the function of each being determined by the associated prestored function instruction means. Some blocks function to generate, transform or display data within the computer. Others function to control operation of physical apparatus, such as programmable test instruments, through the external communications interface. The function instruction means of the latter type include means for generating commands to program settings of the instruments. A block and associated function means can be provided which, respectively, represents and simulates the physical system in the block diagram, e.g., for comparing operation of a prototype device with a design simulation of the device. 
     The function instruction means can include one or more user-settable parameters responsive to user operation of the input means to modify the function thereof. Similarly, the function instruction means for certain blocks, such as a digitizer, can be operated to produce or transform a two-dimensional signal with the graphic display means operable to display such signal as two-dimensional graphic data. Preferably, a means is provided, which is responsive to operation of the user-operable means to select and position a feature of the displayed two-dimensional graphic data, for manipulating the function instruction means of such block to modify the function thereof. Such means correspondingly includes means for transforming the displayed feature from display coordinates into terms of settings of the instrument to reset its parameters as the associated function instruction means are readied for execution. 
     The preferred embodiment further includes means actuable by the user-operable means for the user to select and group the displayed blocks and their associated connections to form a macro-block executable as a unit by the processor. The block storage means can correspondingly include means for storing the macro-block for manipulation in same manner as blocks of the first, second and third type Such means can further include means for storing any parameters associated with the blocks constituting a macro-block and enabling the user selectively to modify such parameters. A means is preferably provided for the user to nest macro-blocks within other macro-blocks 
     The invention enables a user to plan, decompose and carry out measures, experiments, signal analysis and other complex tasks, concentrating on the goals of the task at hand, by expressing the task in a way familiar to the typical user--a block diagram. It enables the user to program in the semantics of a given problem, with little or no interference from the syntax of programming language. By working with schematic concepts, the user&#39;s concentration is focused on the problem, the system is easier to use and learn and the cognitive burden is less. The system allows the user, in effect, to draw programs with predefined processing elements or blocks and interconnections. If a block diagram becomes too complex, the user can readily reduce its complexity by grouping several blocks together and displaying them as a single, higher-level macro-block. 
     In a preferred embodiment, the user selects desired blocks from a menu displayed in one portion of the graphic display, positions the selected blocks in an editing area, and interconnects the inputs and outputs of the blocks as desired to direct the data flows. The user may group blocks into macro-blocks to reduce visual complexity and to prevent overflow of the editing area. The macro-blocks can then be added to the collection of predefined blocks. The user may also place non-executable &#34;empty&#34; blocks in the editing area and can subsequently refine them into collections of predefined blocks as the user&#39;s grasp of the problem becomes more concrete. 
     After having drawn a diagram that represents what the user intends to accomplish, the user can then execute the diagram. From the user&#39;s viewpoint, the diagram is the program. The diagram also self-documents both the program and the particular experiment or analysis task that has been designed and executed. Preferably, the software is written in an object-oriented language, which facilitates the documentation and information presentation task by enabling a user to &#34;look inside&#34; blocks at descending layers of complexity while leaving that complexity behind for ease of manipulation and editing of the block diagrams. 
     The foregoing and other objects, features and advantages of the invention will become more readily apparent from the following detailed description of a preferred embodiment which proceeds with reference to the accompanying drawings. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIG. 1 is an illustration of a graphical display screen showing a simple application of the block diagram editor system of the invention to a signal analysis problem. 
     FIG. 2 shows the output information appearing on the display screen after executing the example of FIG. 1. 
     FIG. 3 is a diagram of the software structure implementing the block diagram editor system of the invention. 
     FIG. 3a is a diagram of the Block Editor Model-View-Controller relationships in the software structure of FIG. 3, the dotted lines indicating dependency relationships. 
     FIG. 3b is a diagram of the DisplayBlock-BlockParams-FormFillOut relationships in the software structure of FIG. 3, each question/answer pair being one &#34;HorizFillInTheBlank.&#34; 
     FIG. 3c is a diagram of the execution manager portion of the software structure of FIG. 3. 
     FIG. 4 is a diagram illustrating an example of operation of the execution manager software to execute a block diagram similar to FIG. 1. 
     FIG. 5 is a diagram of the layout and interconnection of a computer and programmable test instrumentation system for stimulating a device under test and detecting and analyzing the response in accordance with the invention. 
     FIGS. 6-11 illustrate the steps of assembling a block diagram and associated diagram configuration data base in the computer of FIG. 5 for stimulating and detecting a response from the device under test. 
     FIG. 12 illustrates the further steps of adding blocks to the block diagram of FIG. 11 for analyzing and displaying signal data returned by the digitizer from the device under test. 
     FIGS. 13 and 14 show the screen of FIG. 12 during operation of the system to set parameters for a selected generator block in the block diagram. 
     FIG. 15 shows the step of setting initial or default parameters for the digitizer. 
     FIG. 16 shows selection on the pop-up menu of the &#34;execute diagram&#34; command to commence execution. 
     FIG. 16a shows the screen after partial execution of the block diagram, with a graphical display of a waveform output from the digitizer under the initial settings of FIG. 15. 
     FIG. 17 shows how the user can modify operation of the digitizer by user-interactive, signal-viewing control of the signal acquisition window. 
     FIG. 17a shows the screen after partial reexecution of the block diagram using the digitizer settings modified in FIG. 17. 
     FIG. 18 shows the step of modifying the digitizer default settings to conform to those set in FIG. 17. 
     FIG. 19 shows the screen after complete execution of the block diagram,, including graphs of the digitizer output waveform and the output of the polar block. 
     FIGS. 20-23 illustrate the procedure for consolidating a portion of the block diagram of FIG. 12 into a macro block. 
     FIG. 24 illustrates the step of adding the macro block to the resource list. 
     FIGS. 25-30 illustrate a capability provided in the invention for the user to enter a block, such as the device under test, to view further layers of a detail of the, structure represented by the block. 
     FIG. 31 is a top level state diagram for the block diagram editing software utilized in the invention. 
     FIG. 32 is a state diagram of the &#34;editor pane red button activity&#34; state in FIG. 31. 
     FIGS. 32a, 32b and 32c are state diagrams for the &#34;draw connection,&#34; &#34;move block&#34; and &#34;move connection&#34; states in FIG. 32. 
     FIG. 33 is a state diagram of the &#34;editor pane yellow button activity&#34; state in FIG. 31. 
     FIG. 34 is a state diagram of the &#34;block menu activity&#34; state in FIG. 31. 
     FIG. 34a shows the Block Input state diagrams for the &#34;add an/input to block,&#34; remove an input from block&#34; and &#34;label an input&#34; states in FIG. 34. 
     FIG. 34b shows the Block Output state diagrams for the &#34;add an output to block,&#34; &#34;remove an output from block&#34; and &#34;label an output&#34; states in FIG. 34. 
     FIG. 35 is a state diagram of the &#34;macro menu activity&#34; state in FIG. 33. 
     FIG. 36 is a state diagram of the &#34;macro block editor menu activity&#34; state in FIG. 33. 
     FIG. 37 is a state diagram of the &#34;block editor menu activity&#34; state in FIG. 33. 
     FIG. 37a is a state diagram of the &#34;create macro block&#34; state in FIGS. 36 and 37. 
     FIG. 37b is a state diagram of the &#34;label block&#34; state in FIGS. 36 and 37. 
     FIG. 38 is a state diagram of the &#34;execute the diagram&#34; state in FIG. 37. 
     FIG. 39 is a state diagram of the &#34;blue button activity&#34; state in FIG. 31. 
     FIG. 40 is a state diagram of the &#34;resource list pane yellow button activity&#34; state in FIG. 31. 
     FIG. 41 is a state diagram of the &#34;resource list pane red button activity&#34; state in FIG. 31. 
     FIG. 42 is a functional block diagram of signal viewing control of a digitizer during block diagram execution. 
     FIG. 43 is a top level state diagram of the procedure for signal viewing control. 
     FIG. 44 is a state diagram of the &#34;acquire data&#34; state in FIG. 43. 
     FIGS. 45a and 46a are state diagrams of the &#34;vertical settings&#34; and &#34;horizontal settings&#34; states, respectively, in FIG. 44. 
     FIGS 45b and 46b are diagrams graphically illustrating operation of the procedures of FIGS. 45a and 46a, respectively. 
     FIG. 47 shows how the user controls operation of a power supply via signal viewing control. 
     FIG. 48 is a top level state diagram of the procedure for signal viewing control of a power supply. 
     FIG. 49 shows how the user controls operation of a function generator via signal viewing control. 
     TABLES 1, 2 and 3 summarize examples of block functions used in the block diagram editor system for signal analysis and test instrument control. 
     TABLE 4 shows an alternate form of the Block Editor menu, together with a brief summary of the functions listed in the menu. 
     APPENDIX A is a program listing in C programming language of a block function routine for controlling an example of a stimulus-type test instrument, a function generator, in accordance with the invention. 
     APPENDIX B is a C-language program listing of a block function routine for controlling an example of a response-detecting instrument, a digitizer, in accordance with the invention. 
     APPENDIX C is a description and example of a C-language block function routine used in the present invention for performing signal analysis, polar conversion, on signal data. 
     APPENDIX D is a format and example for the block diagram of FIG. 16 of the netlist created by execution of the block diagram. 
     APPENDIX E is a C-language listing of the definition of SAMPLE in the Experiment Manager. 
     APPENDIX F is a C-language listing, with comments, of a generalized block function. 
     APPENDIX G defines the variables employed in program for signal viewing control of a digitizer. 
     APPENDICES H and I are Smalltalk-80 program listings, with comments, for the methods of determining vertical and horizontal digitizer settings under signal viewing control. 
     APPENDIX J is a Smalltalk-80 program listing, with comments, for the key methods for controlling a power supply via signal viewing. 
    
    
     DETAILED DESCRIPTION 
     This description begins with a general description of the overall hardware and software structure as used, first, for signal analysis and, second, for managing an experiment involving an electrical circuit (device under test). Then, operation of the system is described from the user&#39;s viewpoint. Finally, the block diagram editor software structure and operation are described in detail. 
     1.0 GENERAL HARDWARE AND SOFTWARE STRUCTURE 
     1.1 Computer System 
     Referring to FIG. 5, a computer system 50, arranged and programmed in accordance with the invention, is connected to an instrumentation system 52 to provide an Experiment Manager system. Computer system 50 comprises a general purpose digital computer 54, conventionally including a central processor and random access and hard disk memory (not shown). A user interacts with the computer through a graphic display means 56 and user input means including a keyboard 58 and a three-button mouse 60. (With some rearrangement of the software, a one-or two-button mouse could be used.) A suitable form of computer is provided by a Tektronix 4404 artificial intelligence workstation, which is commercially available with a Tektronix 4404 integrated CRT display serving as the graphic display means and with the aforementioned keyboard and three-button mouse. 
     1.2 Instrumentation System 
     As used in an experiment manager system, the computer system 50 is connected to the instrumentation system 52 by data communications means including a bi-directional RS-232 data bus 62, a protocol converter 64 and an IEEE 488 (GPIB) bi-directional data bus 66. The protocol converter is suitably an IOtech Model MAC488 bus controller. The test instrumentation system can be composed of any of a wide variety of programmable electronic test instruments, compatible with the IEEE 488 protocol. Workstations other than the Tektronix 4404 can be used, which have a built-in GPIB interface, such as the IBM/PC-AT. 
     In the illustrated example of test instrumentation system 52, three signal generating instruments 68, 70, 72 and a signal detecting instrument 74 are shown connected to bus 66. Each of the signal generating instruments is connected via suitable conductors 69, 71, 73 to a device under test 76 comprising an electrical circuit. Conductors 69, 71, 73 are connected via suitable probes to locations in the device under test to stimulate the circuit as determined by the user. The response-detecting device 74 is similarly connected via a conductor 75 and suitable probe to a test point of interest on the circuit of device 76. 
     For purposes of example to illustrate application of the invention to management of an experiment, the device under test 76 is an amplitude modulator. The stimulating test instruments 68 and 70 are each a Tektronix FG5010 Programmable Function Generator and instrument 72 is a Tektronix Model PS5010 programmable power supply. An alternative example of test instruments 68, 70 can be the Analogic Corp. Model DATA 2020 polyonomial waveform synthesizer, which is also programmable and controllable by IEEE 488 protocol. The response-detecting instrument 74 is preferably a Tektronix Model 7D20 digitizer. An alternate example of response-detecting instrument 74 is a programmable spectrum analyzer. 
     1.3 General Software Structure 
     For purposes of the example described herein, computer 54 is assumed to be a Tektronix 4404 workstation programmed to run programs written in Smalltalk-80 and C programming languages under Uniflex or another UNIX-like operating system. The computer is further programmed, in accordance with the invention, with block diagram editor and execution manager software structured as shown in FIG. 3. The block editor software is preferably implemented in Smalltalk-80 or other objett-oriented programming language Such languages are known and described in the art, for example, in A. Goldberg, &#34;Smalltalk-80, the Interactive Programming Environment&#34; published by Addison-Wesley (1984); &#34;4404 Artificial Intelligence System: Introduction to the Smalltalk-80 System&#34; published by Tektronix (1984); and BYTE Vol. 6, No. 8 (August 1981) and Vol 11, No. 8 (August 1986). Portions of the execution manager software are based on a modification of BLOSIM, referred to herein as IBLOSIM (for Interactive BLOck SIMulator), as shown in FIG. 3c and described in Section 4.0. These portions have been implemented in C programming language, which is well-known in the art, and the remainder is programmed in Smalltalk-80. 
     1.3.1 Block Editor Software 
     This software operates under control of a Block Editor Main Control routine, indicated by block 80. The software structure includes a Select Block routine 82, which is first invoked by the Block Editor Main Control routine. When actuated by the user as described below, this routine takes a selected block from a prestored resource list 83. Control is then shifted to a Position Block routine 84 which in turn accesses a Display Block routine 85 which causes conventional graphics software to display the selected block on the graphical display 56. The displayed information is stored in a display information memory 86 that continues to be updated as a block diagram is assembled on the computer by the user. 
     After positioning two or more blocks on the display, the user can then invoke a Connect Blocks routine 88. This routine in turn enables a Display Connection routine 89 to display interconnections selected by the user. These interconnections are also stored in the display information memory 86. 
     Once the block diagram has been assembled, the user can invoke a Set Parameters routine 90. Many of the functional blocks, such as those representing instruments 68, 70, 72 and 74, require that initial or default settings of parameters for operation of the instruments be input to the system. Invoking routine 90 for such a block causes a Display Parameters routine 91 to display a table of parameters for the instrument associated with the block. The user then fills in the desired parameters. As this is done for each block, the display parameters are added to the display memory. 
     Each of routines 84, 88 and 90 also provides block position, interconnection and parameter setting information to a diagram configuration data base 87. This data base is structured to provide data used by the execution manager software, described below, to create a netlist in the format of APPENDIX D that is used by the execution manager to control execution of the block diagram. In an operative embodiment of the system, this netlist is compiled after the block diagram has been fully assembled but, alternatively, it can be compiled incrementally, as the block diagram is being assembled, to attain faster execution. 
     The block editor&#39;s operation is described in more detail in Section 2.2 and its software structure is described in Section 3.0. 
     1.3.2 Execution Manager Software 
     After completing a block diagram, the user actuates the execution manager software through the Block Editor Main Control routine. This action invokes an Execute Diagram routine 92, which creates from the block diagram data stored in data base 87 a netlist, such as that of APPENDIX D, to control execution of the diagram. Routine 92 also accesses a prestored Function Execution Library 93, containing block function application subroutines that correspond to and implement each of the functions in resource list 83. The netlist dictates to the Execute Diagram routine which functional subroutines to use and how to link these subroutines for execution in the sequence embodied in the diagram. 
     As each function of the diagram is being executed, interim and output data are stored in an execution data storage 94. Then, as execution of each function is completed, the stored data is either output to the next function routine as determined by the netlist interconnections, or returned to the function subroutine to generate control setting commands for transmission via the communications channel to the appropriate test instrument of instrumentation system 52. 
     During execution of each block, the Execute Diagram routine provides a command to the Main Control routine to cause the block being executed to be highlighted on the display. In this stage of operation, the user can intervene in execution of the diagram to alter the parameters of a selected block and its associated function and re-execute the diagram. This capability is particularly useful to enable the user interactively to control the operation of the test instruments. It is further enhanced, for control of test instrumentation, by addition of a signal viewing capability that enables the user to display and manipulate features of operation of the test instruments in two dimensions. This capability is described below in Section 5.0. 
     Section 2.1 below outlines operation of the execution manager to execute the block diagram of FIGS. 1 and 2. Section 4.0 is a more detailed description of the software structure of the execution manager. 
     2.0 SYSTEM OPERATION 
     2.1 Signal Processing 
     FIGS. 1 and 2 illustrate a simple application of the block diagram editor system of the invention to a signal processing problem. In this example, the user has constructed a block diagram, shown in FIG. 1, to generate and process a signal. Upon execution of the block diagram and underlying software assembled as described above, the originally-generated signal and signals output from the subsequent processing steps are graphed, as shown in FIG. 2. 
     Upon execution, the current block diagram is first checked for validity, i.e., to make sure all connections are proper. Next, in operation of the execution manager software, the Smalltalk process 96, shown on the left side of FIG. 4, is &#34;forked&#34; into a C process 97, shown on the right side of FIG. 4. The C process runs as a child process of the Smalltalk process, using pipelines 98, 99 for transfer of information between the two processes. 
     The Smalltalk process 96 converts the block diagram that the user has constructed into a netlist formatted like that in APPENDIX D. This is done by scanning the underlying data structures corresponding to the current block diagram, as stored in diagram configuration data base 87 (FIG. 3), and creating a list of all the blocks, their parameters and their connections. Then, the netlist is shipped to the C process, which includes a netlist interpreter and the Function Execution Library 93. The netlist interpreter handles the setup, scheduling and execution of the block functions Under this routine, the netlist is interpreted, the parameters are set for the various block function routines called by the netlist, and the routines are scheduled and then executed The routines are scheduled to be executed in an order determined by the direction of data flow indicated by the interconnections shown in the diagram. 
     Before the function corresponding to each block commences execution, a block inversion request is transmitted by the C process 97 to the Smalltalk process 96 via pipe 99. In response to this request, the Smalltalk process causes the graphics software to reverse video or highlight the block to be executed to provide feedback to the user. In the case of signal view control, e.g., of the digitizer, this gives the user an opportunity to modify the parameters of the block about to be executed, as discussed further below. 
     Error messages and waveform data are transferred back to the Smalltalk process during execution of the block diagram. Such transfers cause graphical display objects to appear, if they do not already exist. These display objects then read and display the error messages or waveform data. The names of the blocks from the original block diagram are installed as the titles of the graphical display objects. When the entire diagram has finished executing, the C process dies and control returns to the user via the BlockEditor user interface. 
     In regard to the example of FIGS. 1 and 2, the sequence of execution commences with the routines corresponding to generator blocks, which generate signal data at their outputs. The example illustrated in FIGS. 1 and 2 shows generation of a sine function, sin(x). Execution then proceeds to the routines corresponding to transforming blocks, which accept and transform the signal data and provide modified signal data at their outputs. The example shows successive transformations, first, of the sine function signal by a fast Fourier transform (Rfft) and, second, by a polar conversion function (Polar), a listing for which is contained in APPENDIX C. 
     Finally, the output signal data are input to appropriate routines for the terminal blocks shown in the block diagram. The example of FIGS. 1 and 2 shows two such blocks (Graph), each of which has the function of graphing the signal data output from the block to which it is connected. An alternative form of block (e.g., &#34;sink&#34; in FIG. 4) can be used to dead end any signal data that is not of interest. The output of each Graph block is then transmitted back to the Smalltalk process, via pipe 99, for graphical display as shown in FIG. 2. 
     This simple example shows how the system of the invention can be used for simulation purposes. As will be seen from the ensuing description, a live signal could alternatively be input to computer system 50 via an appropriate communications interface for analysis similar to that illustrated in FIGS. 1 and 2. Similarly, signals can be generated in the manner illustrated by FIGS. 1 and 2 and output, through an appropriate interface, either directly to a communications system or in the form of control setting commands to other test instruments. 
     2.2 Experiment Manager 
     This section describes how a user interacts with a computer system 50 and the software of the invention to build, modify and execute block diagrams for purposes of managing an electrical circuit experiment. It is equally applicable to any of the foregoing applications. In this description, operation of the three-button mouse is couched in terms of button color, as used in the Goldberg text, i.e., the left or &#34;select&#34; button is red; the middle or &#34;menu&#34; button is yellow; and the right or &#34;window&#34; button is blue. 
     2.2.1 Editing and Resource Panes 
     Referring to FIG. 6, upon start-up, the user will see a view on 100 on screen 56 with &#34;BlockEditor&#34; in title tab 102. If there is no BlockEditor view on the screen, the user enters the following text in the work space: &#34;BlockEditor openOn: Universe new&#34; and then selects this line of text and executes it. The user then designates a location for the BlockEditor view in response to a prompt. 
     The BlockEditor view comprises two panes, an editor pane 104 on the left and a resource list pane 106 on the right. The resource list can be a multipane list. The BlockEditor view 100 may contain an entire block diagram, in which case the title tab will read &#34;BlockEditor,&#34; or it may contain a &#34;macro expansion,&#34; in which case the title tab 102 will contain the name of the macro, e.g., &#34;amModulation Experiment&#34;, as shown in FIG. 6. The term &#34;macro&#34; refers to a collection of blocks and connections that have been grouped into a higher level module and the term &#34;macro expansion&#34; is the expanded display of that macro. The term &#34;macro expansion BlockEditor&#34; will refer to a BlockEditor view in which a macro expansion is being edited. 
     The editor pane can contain (1) blocks--labeled rectangles with white interior; (2) macros--labeled rectangles with patterned interior; and (3) connections--lines connecting block or macro output terminals (black dots, by convention to right of the block) to block or macro input terminals (small circles, by convention to the left of the block), as shown in FIG. 9. 
     The resource pane has a vertical scroll bar 107, which appears when the cursor is in the resource pane, as shown in FIG. 6. It disappears when the cursor is moved into the editor pane, as shown in FIG. 7. The editor pane has X-Y scroll bars 108, 110, also as shown in FIG. 7. Individually, the scroll bars work just like a conventional Smalltalk vertical scroll bar. Simultaneous X-Y scrolling can be actuated by depressing the left shift key on keyboard 58 and pressing the red button on mouse 60. The left shift key can then be released. As long as the red button is held down, the screen will scroll in two dimensions. 
     2.2.2 Pop-up Menus 
     The editor pane has three pop-up menus, each of which contain a collection of editing commands. All three pop-up menus are invoked by pressing the yellow mouse button. The first menu is the BlockEditor menu 112, shown in FIG. 9. This menu is brought up by pressing the yellow mouse button while the cursor 114 (FIG. 8) is not inside a block or a macro. When the BlockEditor menu is brought up in a macro expansion view, two additional commands--&#34;accept&#34; and &#34;cancel&#34;--are included and the &#34;execute diagram&#34; command is omitted. Other combinations of functions can be included in the BlockEditor menu, for example, as shown in TABLE 4. 
     The second form of menu is a block menu 116, as shown in FIG. 13. The block menu is brought up by pressing the yellow mouse button with cursor 114 (FIG. 8) inside a block. 
     The third form of menu is a macro menu, which is brought up by pressing the yellow mouse button with cursor 114 inside a macro block. It has one menu item: 
     enter macro. 
     The resource list pane 106 contains a list of available functions, which is stored in resource list memory 83 (FIG. 3). A function is selected from this list by placing the cursor on the function name and pressing the red mouse button. The resource list pane has one yellow button menu with one menu item: remove entry. The &#34;remove entry&#34; operation deletes the selected function from the resource list pane and deletes the software associated with that function from the system. 
     2.2.3 Constructing Block Diagrams 
     A block or macro is added to a block diagram in editor pane 104 by selecting its name from the resource list in pane 106. In FIG. 6, the &#34;amModulator&#34; function 116 has been selected After selecting, the user moves the cursor into the editor pane and the cursor will change to represent the selected function as a block 118, as shown in FIG. 7. To place the block, the user moves it to a desired location by moving the mouse and positions the block by pressing the red mouse button. As shown in FIG. 8, the cursor will change back to the normal cursor, in the form of an arrow 114, and the block will be fixed in position on the editor pane. Small circles 120 on the left side of block 118 indicate input terminals and a small circular spot 122 on the right side of the block indicates an output terminal. 
     A block label 124 appears in the block 118. Initially, the block label is identical to the function name for the function selected from resource pane 106. Block labels must be unique so the block diagram editor software will attach an asterisk to the block label of a selected function if another block bearing the same label has already been positioned in editor pane 104. The user can, however, change the label of a block. 
     Referring to FIG. 9, the user can continue to build up a block diagram by selecting functions from resource pane 106 and positioning each selected function as a block in editor pane 104 In the same manner that the user selected and positioned block 118, the user can select and position blocks representing two function generators 126, 128, a power supply 130 and a data acquisition device 132. Comparing FIG. 9 and FIG. 5, it can be seen that the block diagram contains functional blocks corresponding to the test instruments 68, 70, 72 and 74 connected to the device under test 76 in instrumentation system 52. 
     To make the block diagram descriptive of the function that it is performing, the user can modify the names of the blocks. To do so, the user invokes the BlockEditor menu 112 and selects the item &#34;label block&#34; shown in the menu. Referring to FIG. 10, the display provides a cursor 134 to the user: Label which block? The user positions the cursor on the block that is desired to be renamed and presses the yellow mouse button. 
     Referring to FIG. 11, block 130 has been selected. This action causes a prompt to appear over the selected block, requesting the user to type in a new block label. As it is typed in, the new label 138 appears in prompt 136. When the user presses the yellow mouse button, the new label is inserted in the selected block. FIG. 12 shows blocks 126, 128, 130 all relabeled using this procedure. The same name must not be duplicated in any other blocks in a block diagram because these names are later used in the netlist that is used to execute the diagram (see APPENDIX D). 
     Returning to FIG. 9, before a diagram can be executed, all of the inputs and outputs must be connected. To connect an output to an input, the user moves the cursor to an output of a block, for example, output 122 of block 118, and presses the red mouse button. The user then moves the cursor away from the output and the BlockEditor software displays a line extending from the output to the current cursor position. To complete a connection, the user points the cursor to an input, such as input 140 of block 132, and depresses the red mouse button. A connection 142 is then drawn between output terminal 122 and input 140. Connections are drawn in like manner between the output terminals 146 of blocks 126, 128, 130 and the input terminals 120 of block 118. To facilitate routing of connectors 144, the user can choose to put points 148 in the interconnection lines to produce an interconnection routing with only horizontal and vertical lines and to avoid other blocks. This is done by pressing the red mouse button at each location where direction of the interconnection line is to change. 
     The user can also modify connections that have been made. To select a connection, the user moves the cursor to one of the connection points, either an end point or one of points where directions changes, and press the red mouse button. To select an end point, the user places the cursor in the center of the input or output terminal. The connection will highlight, indicating successful selection. To move a connection point, the user moves the cursor to that point and presses the red button. The line or lines connecting to that point will &#34;rubber band&#34; and the user moves the point to its new location and releases the red button. End points of interconnection lines can be moved to any unused input or output. To delete a connection, the user moves any of the connection points outside of the BlockEditor pane 104. To reroute a connection, the user deletes the connection and redraws it. A selected connection may be deselected either clicking the red mouse button on it again or by selecting something else in the diagram. 
     The user can also select and either move or delete a block that is already on the diagram. The user does this by positioning the cursor within the block and pressing the red mouse button. The block will highlight, indicating selection. To move a selected block, the user moves the cursor to that block, presses the red mouse button, drags the block to a new location, and releases the red button. To delete a block, the user selects it and drags it outside of the editing pane and releases the red button. To add a block to the resource list, the user drags the block into the resource list pane 106 and releases the red button. If the block&#39;s name is not already there, it will be added to the resource list. 
     Referring to FIG. 12, additional blocks can be added to the block diagram as needed for a particular experiment. For example, signal analysis blocks 150, 152 are connected in series to an output terminal 154 of signal acquisition block 132. Connected to one output terminal 156 of block 152 is a &#34;graph&#34; block 164. Connected to the other output terminal 160 of block 152 is a &#34;sink&#34; block 162. Blocks 150, 152 perform signal analyses on the signal output from block 132 at terminal 154. The names of these blocks are stored in the resource list pane 106 and the BlockEditor software includes subroutines, selectable by selecting the associated function name and block, for performing the function indicated by the function name. Block 164, also selected from the list in pane 106, invokes a graphing function for graphically displaying the signal that is output on terminal 156 from block 152. Block 162, &#34;sink,&#34; is also listed in pane 106 and enables the user to disregard data from output terminal 160 of block 152. 
     2.2.4 Setting Initial Block Parameters 
     Referring to FIG. 13, some blocks have initial or default parameters for the user to set. The user does this by moving the cursor into a block whose parameters are to be set, invokes the block menu 116, and selects &#34;set parameters&#34; from the menu. If the block has no parameters, the cursor will remain a normal, arrow cursor. If the block has parameters, the cursor will change to a &#34;wait&#34; cursor, followed shortly by a prompt to locate a parameter view. In FIG. 13, the user has selected block 128, which represents and controls the function generator 70 in FIG. 5. A parameter view or menu 168 for the selected block then appears, as shown in FIG. 14. 
     The parameter view is divided into left and right sides. The panes on the left side define the parameters of the particular block. The panes on the right side of the view are used to specify the settings of the parameters for the function associated with the selected block. In some cases, the parameter can be expressed in a linear representation as a series of buttons, as in the case of the &#34;waveform&#34; parameter in menu 168. The user can select one of the choices, e.g., &#34;sine&#34;, by placing the cursor over it and depressing the red mouse button. If the parameter is not specified by buttons, the user moves the cursor into the right side pane and types in a number to specify the requested parameter. Once the parameters have been input, the user accepts the parameters by selecting &#34;accept&#34; 169 from the BlockEditor menu invoked by pressing the yellow (middle) mouse button while the cursor is still in the parameter view. 
     FIG. 15 shows the foregoing parameter-setting procedure as applied to digitizer 74, represented in the diagram as block 132. The operation of digitizer 74 is initially controlled by default parameters programmed into the associated block 132 when initially constructed. These parameters can be reset in the same manner as for generator blocks 126, 128, 130. Referring to FIG. 15, selecting the &#34;set parameters&#34; item brings up the parameters pane 170 for block 132. The format of this pane is similar to parameter pane 168 (FIG. 14), previously described. The user can select the various buttons shown on the pane and input the numerical parameters desired to specify initial or default operation of digitizer 76. The values shown are exemplary default or initial settings that can subsequently be modified interactively by the user during execution of the diagram. To interactively modify these default parameters, the user selects &#34;no&#34; after the query &#34;Use acquisition window.&#34; 
     2.2.5 Executing a Block Diagram 
     Once assembled, the block diagram can be executed. To execute a block diagram, the use selects &#34;execute diagram&#34; from the BlockEditor menu 112, as shown in FIG. 16. If all of the inputs and outputs are connected, the diagram will execute; otherwise, an error notification will appear. I that happens, the user can press the red mouse button to proceed with connecting any unconnected outputs. 
     There will be a short pause after selecting &#34;execute diagram&#34; and then each block will &#34;reverse video&#34; as the processor executes the associated functions in the software. Some blocks prompt the user to specify a location to display an output set of signal data. After a location is specified, execution of the block diagram continues. If the diagram is reexecuted, and the data display windows are still present, the new data will be automatically routed to those windows. 
     FIG. 16a shows an example of the windows appearing on display 56 after partial execution of the block diagram of FIG. 16. Window 172 displays a waveform output from digitizer 74 to computer system 50. The signal viewing menu 174 can be invoked at this point in the operation to enable the user to modify the signal acquisition window of the digitizer. 
     2.2.6 Modifying Block Parameters 
     During execution of the diagram, however, the user can modify operation of the digitizer interactively by changing the signal acquisition window thereof on the graphic display 56. FIGS. 16a, 17, 17a, 18 and 19 illustrate this procedure from the user&#39;s viewpoint. Section 5.0 describes the internal structure and operation of this capability. 
     The user selects the desired form of signal viewing control on menu 173 in FIG. 16a. For this example, the user has selected &#34;zoom in.&#34; This command invokes a standard Smalltalk-80 routine that prompts the user to designate a rectangle 174 which encompasses a portion of the signal that is of interest to the user. This rectangle can be either smaller or larger than the displayed signal, although its effectiveness is constrained by the capabilities of the instrument being controlled, as discussed in Section 5.0. 
     To define this rectangle, as shown in FIG. 17, the system displays an upper left corner symbol (not shown), which the user positions by depressing and holding down the mouse pointer button. Then the user moves the mouse pointer to position the lower right corner of rectangle 174, and then releases the button. The designated area is stored, as a variable screenRect, which is then processed, as described in Section 5.0, to establish a new signal acquisition window corresponding to rectangle 174. 
     FIG. 17a shows the windows after partial reexecution of the block diagram using the new signal acquisition window specified by rectangle 174. A new waveform is displayed in window 172. It corresponds to the waveform shown in FIG. 16a but is based on newly acquired data, not merely an expansion of reformated, stored data from the prior execution. 
     The user decides whether the waveform shows what is desired. If not, the user can again modify the signal acquisition window. Once satisfied, the user can again invoke the parameter view 170 from window 104, as shown in FIG. 18. The values displayed are those derived from the desired acquisition rectangle 174. This time the user selects these values for complete execution of the block diagram by answering &#34;Yes&#34; to the query &#34;Use acquisition window.&#34; Alternatively, the user can again invoke menu 173 (FIG. 16a) and select &#34;Use acq window,&#34; to perform the same function. 
     The diagram is then executed completely, with the results being shown in FIG. 19. Window 172 again displays the digitizer output waveform for the desired acquisition rectangle 174. Window 178 displays a graph of the amplitude output of polar analysis block 152, as specified by the connection to graph block 164. 
     2.2.7 Creating Macros 
     At times it may be desirable to group several blocks together and treat them as if they were one functional block. This is accomplished by using the &#34;build macro&#34; menu function, as shown in FIG. 20. All the functions that are intended to be included in the macro must appear in the editor pane 104 and must be appropriately connected. The user positions the cursor in the editor pane and selects &#34;build macro&#34; from the BlockEditor menu 112. The cursor changes from an arrow to a swirl 114a, as shown in FIG. 21. The user then locates the cursor on each block and presses the red button once to include that block in the macro. The blocks will highlight as they are selected. 
     Once all blocks to be included in the macro have been selected, the user moves the cursor to an open area of the editor pane and presses the red button twice. The highlighted blocks and associated connections are then erased from the display screen, as shown in FIG. 22, and the user is prompted to type a name into box 176. A unique name must be applied to the macro to distinguish from the names of other blocks already in use. Once a name is provided, the cursor will then change to represent a macro block which can be positioned in the diagram, as shown in FIG. 23. The connections from blocks inside the macro to blocks outside the macro will then be redrawn. 
     In FIG. 21, the user has selected blocks 150, 152, 162, 164 for inclusion in a macro. In FIG. 23, after assignment of a name, the functions of all of these blocks are included in a single block 180, named &#34;magSpectrum.&#34; This is the &#34;bottom up&#34; way to create a macro. 
     Once created, a macro behaves just like any other block, and can be added to the resource list in pane 106. Referring to FIG. 24, to add a block to the resource list, the user drags it, using the mouse with the red mouse button depressed, into the resource list pane and releases the red mouse button. Since the macro is a newly created block, its name is added as label 182 to the resource list. Block 180 will continue to be displayed at its last location. 
     There are also two &#34;top down&#34; ways to create a macro. First, a non-defined function named, for example, &#34;empty macro&#34; can be included in the resource list pane 106 for the user to select and position in the editor pane 104. Once it is positioned it should be relabeled to reflect its intended function. Second, if there is no &#34;empty macro&#34; function in pane 106, the user can move the cursor into the editor pane to 104 and select &#34;add block&#34; from the BlockEditor menu 112. The cursor will change to represent an empty block which the user can move to a desired location and position by clicking the red mouse button The block is then labeled to reflect its intended function. The user will be prompted for the block parameters but none are required for macros. The user can position the cursor in the parameter work space, delete everything between parentheses, and select &#34;accept&#34; from the BlockEditor menu. Next, the user selects &#34;become macro&#34; from the block menu 116. The block will then become an empty macro. 
     2.2.8 Editing Macros 
     To edit a macro, the user moves the cursor inside the macro and selects &#34;enter macro&#34; from the macro menu. The user is then prompted for a screen location for a new macro expansion BlockEditor view. This view will have the macro&#39;s label as its title tab, indicating that a macro is being edited. If the macro is empty, the editor pane will be empty; otherwise, the blocks that constitute the macro will be displayed. The diagram can be edited like a top-level block diagram, with one exception. When the editing session is done, the user selects either &#34;accept&#34; to save the edited macro or &#34;cancel&#34; to delete all changes since the last &#34;accept.&#34; The macro expansion BlockEditor view may then be closed. 
     The user then moves the cursor to the next-higher BlockEditor view (if there are macros within macros, one can be a few levels down), and select &#34;repaint&#34; from the BlockEditor menu 112. Any external changes to the macro, e.g., number of inputs and outputs, will be displayed. Connections will be broken if blocks in the macro to which they were originally connected have been connected to another block or removed. The result of editing a diagram before &#34;repaint&#34; is undefined. 
     To parameterize blocks in a macro, the user selects &#34;enter macro&#34; in the macro menu. Then, the user parameterizes each of the blocks in the macro independently as previously described, entering &#34;accept&#34; for each set of parameters in turn, and then entering &#34;accept&#34; for the macro as a whole. The macro expansion BlockEditor may then be closed. 
     2.2.9 Viewing Block Information 
     Just as a macro includes internal blocks, a block may have some information, such as a textual document or a schematic associated with it. To view this information, the user selects &#34;enter block&#34; from the block menu. If the block has no information, nothing will happen. If the block has any information, the user is prompted to designate a display location. 
     Referring to FIG. 25, the user has selected block 118, the device under test, for viewing prestored background information. At the first level below that of block 118, a prepared schematic of the device under test is displayed in FIG. 25a. Referring to FIG. 26, the user has selected an integrated circuit at the center of the schematic. The selection provides two options: &#34;open sublevel&#34; and &#34;information.&#34; The &#34;information&#34; option enables the user to examine or add notes about the device, as shown in FIG. 27. The &#34;open sublevel&#34; brings up a block diagram for the selected circuit device, as shown in FIG. 28. This information would ordinarily come from the data book about the circuit device, which can be input by the user or obtained online or in machine readable form from the vendor. By selecting the block diagram, the user can descend to another level of detail, again using the two options &#34;open sublevel&#34; and &#34;information.&#34; FIG. 29 shows textual information regarding the block diagram of FIG. 28. FIG. 30 shows a schematic for one of the blocks in the block diagram of FIG. 28. 
     2.2.10 Other Block Editing Functions 
     A number of functions, not shown in the drawings, are included in the block diagram editor program. These functions do, however, appear on the menus. Their operation is described as follows: 
     To erase an entire diagram, the user selects &#34;clear&#34; in the BlockEditor menu. A confirmation prompt asks the user if he really wants to clear the diagram. A &#34;yes&#34; selection will completely erase the diagram. A &#34;no&#34; selection will return control to the BlockEditor, leaving the diagram unchanged. 
     The software also permits the user to display the labels associated with input and output terminals of blocks. When the user selects &#34;show labels&#34; from the BlockEditor menu, labels will appear for all of the inputs and outputs on the currently-displayed blocks. To restore the diagram without labels, the user selects &#34;repaint&#34; from the BlockEditor menu. To change the input or output labels, the user selects either &#34;label input&#34; or &#34;label output&#34; from the block menu. The cursor will change to either the label input or the label output cursor. The user positions the cursor on top of the input or output to be relabeled and clicks the red mouse button. A prompt appears requesting the user to type in the new name. When completed, to exit this mode, the user selects &#34;clear mode&#34; from the BlockEditor menu. To view the new labels, the user selects &#34;show labels&#34; from the BlockEditor menu as described above. 
     The system also provides error messages to the user. Some of the actions that produce an error message include: connecting an output to an output or an input to an input; putting a block too close to another block; or trying to make more than one connection to an input or output terminal. Pressing the red mouse button will erase the error message so that the user can continue editing. If the user is doing something other than positioning a block, he releases the red mouse button to continue editing. If positioning a block, the user moves the cursor to the desired block location and then releases the red button. 
     2.2.11 Adding Blocks to the Resource List 
     Blocks can be added to the system resources list, as shown in resource pane 106. The procedure for adding a block has two major parts: first, add a star interface function to the Function Execution Library software (FIG. 3) to enable the block to be executed and, second, add the block to the resource list. The first step in the procedure is explained below in Section 4.5, which describes the block function building procedures in detail. 
     After the star function has been created, the user adds the function to the BlockEditor resource list as follows: The user selects &#34;add block&#34; from the BlockEditor menu. The user then places as many blocks in the editor pane as are desired to be added to the resource list. The user then selects &#34;add input&#34; from the block menu, and adds the appropriate number of input circles by clicking the red mouse button on the left side of the block once for each input to be added. Next, the user selects &#34;add output&#34; and adds output dots to the right side of the block. If too many inputs or outputs were added, they may be deleted by selecting &#34;remove input&#34; or &#34;remove output&#34; from the block menu. The user places the cursor over the input or the output to be removed and clicks the red mouse button. The user then selects &#34;clear mode&#34; once the correct number of inputs and outputs have been applied to the blocks in the editor pane. 
     Next, the user selects &#34;label block&#34; from the BlockEditor menu and selects a block to be labeled. The block must be labeled with the name of the execution manager star routine The initial block label designates the block function and is always remembered even when the block is relabeled. 
     The user will then be prompted to build the block parameters by editing the following line: 
      #(`questionl` `answerl` `question2` `answer2` `question3` `answer3` `question4` `answer4` `question5` `answer5` `question6` `answer6`). 
     The workspace in which this line appears contains a standard Smalltalk editor. The user replaces the &#34;questionm&#34; with the name of the parameter &#34;answerm&#34; with an appropriate default answer, leaving quotes around the questions and answers. If the user desires the answer to be a set of buttons, &#34;answerm&#34; (including quotes) is replaced with #(&#34;buttonl&#34; &#34;button2&#34; &#34;button3&#34;). The labels given to the buttons will be the actual text sent to the star routine at the time of diagram execution, as shown in the example below. The user may add more questions/answers pairs as needed and should delete unused pairs. If the block does not have any parameters, the user selects all of the text between parentheses and deletes it. The user then selects &#34;accept&#34; from the BlockEditor menu in the editor pane once the parameters have been specified. 
     As an example, the &#34;polar&#34; block parameters (APPENDIX C) are specified as follows: 
      #(`units` #(`RAD` `GRAD` `DEGREE`) `unwrap` #(`TRUE` `FALSE`) `delay` `1.0`) 
     At this point, the user can give the block input and output terminals meaningful names and, if desired, can relabel the block. When the block is finished, the user selects it and positions it in the resource list pane 104, as previously described. 
     2.2.12 Simulation Block 
     In development of electrical circuits and other physical devices, it is conventional practice to develop a computer simulation of the device prior to making it. Once the device is built, it is tested and its operation compared to the results of the simulation. Conventionally, these steps are performed in separate sequential operations and, typically, the comparison is made manually. This is time consuming, error-prone and offers little opportunity to test alternative operating conditions. 
     The present invention enables simultaneous generation and comparison of simulation and actual test data. This is done by adding the simulation program for the device under test as a functional block as well as the information provided in Section 2.2.9. Such a block is added in accordance with the procedures described in Section 2.2.11 and the Sections referenced therein. 
     3.0 INTERNAL STRUCTURE OF BLOCK EDITOR 
     This section provides an overview of the 23 Smalltalk object classes which constitute the BlockEditor program, together with their relationships. Throughout this section, the Smalltalk naming conventions are used--class names and global variables are capitalized and instances of classes are not capitalized. 
     3.1 Classes Central to the Block Editor 
     The block editor is most simply described as a model with two view-controller pairs. The model is class Universe, with the two view-controller pairs being BlockEditorView--BlockEditor and BlockListView--BlockListController. FIG. 3a shows these relationships, with dotted lines indicating dependency relationships. 
     3.1.1 Universe 
     Class Universe maintains all the data about the block diagram and the system resources in data base 87 (FIGS. 3 and 3c). The blocks and connections data structures it contains are sent to the execution manager for preprocessing by the diagram scanner 352 preparatory to execution by IBLOSIM (blocks 354 and 356 in FIG. 3c). The instance variables in Universe are: 
     blocks: a dictionary of blocks and galaxies, i.e., groups of blocks (stars), which point to corresponding displayBlocks and displayGalaxies. The blocks and galaxies correspond to the blocks and macros of a block diagram. 
     connections: a dictionary of connections which point to displayConnections. 
     savedBlocks: points to the global variable CannedBlocksList, which is a dictionary containing the resources available to the block editor. This list is displayed in the BlockListView. The format of CannedBlocksList is the same as that of blocks. 
     dataDisplays: a dictionary containing the names of blocks which perform data display functions (such as the graph or scalar blocks). Entries point to the corresponding object which does the actual data display. 
     listIndex: the index of the currently selected resource in the BlockListView. 
     onGalaxy: a Boolean which is true if this BlockEditor is editing a galaxy (macro), false otherwise. 
     currentGalaxy: if onGalaxy is true, this points to the galaxy (macro) being edited. 
     modelPtr: if onGalaxy is true, this points back to the parent universe or galaxy. 
     3.1.2 BlockEditor 
     The BlockEditor class is the controller for the block editor. It receives all the mouse activity (keyboard activity is usually requested by the other classes) and, if necessary, asks the universe to modify itself. Some activities, such as adding/moving a connection, or building a galaxy, require that the controller collect a large amount of data and then send it to the universe. The BlockEditor also contains the method which initiates the execution manager. The instance variables for BlockEditor are: 
     form: contains the current form of the cursor. 
     tool: if the block editor is in a mode (for example, adding inputs), this contains the symbol for the method to execute when the red button is clicked. Usually it is nil. 
     currentSel: contains the currently selected block or connection. 
     3.1.3 BlockEditorView 
     BlockEditorView class is the view for Universe and BlockEditor. It handles all the display activity for the block editor. BlockEditorView is a fairly standard view, and has no instance variables. 
     3.1.4 BlockListController 
     BlockList Controller is the controller for the resource list pane. The only reason for its existence is the addition of the resource list pane yellow button menu. 
     3.1.5 BlockListView 
     This is the view for the resource list pane. It is only used because the standard SelectionInListView pluggable view does not understand the broadcast messages from class Universe. 
     3.1.6 Block 
     The Block class manages all the logical data for each block. The instance variables for Block are: 
     inputs: an OrderedCollection of the block input names. This list has a one-to-one correspondence with the inputs instance variable in class DisplayBlock. 
     outputs: like inputs, except deals with the block output names. 
     name: the name of the block. The displayBlock label is derived from name. 
     function: the name of the BLOSIM star routine associated with this block. 
     parameters: an Array containing the block&#39;s parameters. 
     insideInfo: a pointer to a user-viewable information about this block; presently limited to Schematics. 
     3.1.7 DisplayBlock 
     The DisplayBlock class manages all the data relating to the display of the block. The instance variables for DisplayBlock are: 
     position: the location of the upper-left hand corner of the block in the BlockEditor view. 
     form: a copy of the block&#39;s form; needed because not all blocks are the same size. 
     extent: the block&#39;s size. 
     myBlock: a pointer to the display Block&#39;s block. 
     inputs: an OrderedCollection of the points representing the block&#39;s inputs, sorted in y order. 
     outputs: an OrderedCollection of the points representing the block&#39;s outputs, sorted in y order. 
     label: a DisplayText representation of the displayBlock&#39;s name. 
     inputExtent, outputExtent, labelExtent: each extent represents the minimum extent the displayBlock can be and still be large enough to display the inputs, outputs, and label, respectively. The actual extent is the largest of the three. 
     parameters: points to the blockParams for this displayBlock. 
     3.1.8 Connection 
     The connection class maintains the information relating to the connections between blocks. The instance variables for Connection are: 
     fromBlock: the name of the block from which the connection is coming. 
     blockOutput: the name of the specific output of fromBlock from which the connection is coming. 
     toBlock: the name of the block to which the connection is going. 
     blockInput: the name of the specific input of toBlock to which the connection is going. 
     3.1.9 DisplayConnection 
     The DisplayConnection class, a subclass of the standard Smalltalk class LinearFit, handles the data related to the actual display of a connection. Most of the data storage and display is dealt with in LinearFit. The only instance variable is: 
     myConnection: pointer to the connection associated with the displayConnection. 
     3.1.10 Galaxy 
     The Galaxy class maintains the information about macros. It is a subclass of Block. Instance variables of Galaxy are: 
     blocks: a dictionary of the blocks that constitute the galaxy. It is organized exactly like the blocks dictionary in Universe. 
     connections: a dictionary of all the connections internal to the galaxy. It is organized exactly like the connections dictionary in Universe. 
     ioConnections: an Ordered Collection of the inside-to-outside connections of the galaxy which maps block inputs and outputs to the macro diagram&#39;s inputs and outputs. 
     3.1.11 DisplayGalaxy 
     The DisplayGalaxy class is a subclass of DisplayBlock. The only difference between a displayBlock and a displayGalaxy is that a displayGalaxy has a patterned fill. It has no instance variables. 
     3.2 Classes Supporting Block Parameterization 
     The block editor has a number of support classes which manage block parameter acquisition, as shown in FIG. 3b. The actual parameters for each block are created when the corresponding displayBlock is labeled for the first time. The user is prompted to substitute the parameters for items in a list, as described in Section 2.2.11. This builds a template that is used to build the formFilloutView whenever &#34;set parameters&#34; is selected from the block menu. The parameter instance variable in the display block points to the blockParams for that block. 
     3.2.1 BlockParams 
     BlockParams contains the template of questions and default answers used to build the formFillout for the block parameters. More than one displayBlock can have a formFillout on the display screen at the same time, allowing the user to edit them concurrently. When &#34;accept&#34; is received by the formFillout, it sends the blockParams the message &#34;finishUp.&#34; The blockParams then stores the new parameter values into the template and sends the new parameter values to the displayBlock. The instance variables for BlockParams are: 
     template: an OrderedCollection of three-element OrderedCollections. Each three-element orderedCollection represents one parameter. The first element is a string containing the parameter name, such as `risetime` or `units.` The second element is the default answer (for single-valued parameters) or an array of strings (for buttons as shown in FIGS. 14 and 15). The second element could contain values such as `1.5` or #(`RAD` `GRAD` `DEGREE`). The third element is the current answer, such as `1.7` or `DEGREE.` The arrow after the parameter name in the formFillout is added during the creation of the formFillout. 
     showDefaults: a Boolean, which if true, will show the default answer, and if false, will show the current answer. 
     ansOC: anOrderedCollection used in the BlockContext which is executed when the formFIllout is accepted. The new parameters are stored into ansOC. 
     displayBlock: points back to the displayBlock associated with this blockParams. 
     3.2.2 FormFillout 
     FormFillout, a subclass of standard Smalltalk class FillInTheBlank, takes a collection of questions and answers and prompts the user to edit the answers. The user then accepts the answers, whether or not any editing has taken place. This closes the formFilloutView. FormFillout is the model for FormFilloutView and FormFillout Controller. The instance variables for FormFillout are: 
     okayToLeave: a Boolean which is true if the formFillout is scheduled, false if the formFillout has control. 
     BlockParam: points back to the blockParams which invoked this formFillout. This is used to determine where to send the new parameters. 
     3.2.3 FormFilloutController 
     FormFilloutController is the controller for FormFillout. It waits for an accept message, and then tells all the subcontrollers to perform their accept actions. It has no instance variables. 
     3.2.4 FormFilloutView 
     FormFilloutView is the view for FormFillout. It is a subclass of FillInTheBlankView. FormFilloutView builds the view and starts up the controller. A formFilloutView consists of messageView-answerView pairs, which are basically fillInTheBlankViews displayed horizontally instead of vertically. The buttonViews are a group of OneOnButtons with a ValueHolder as their connector. FormFilloutView has no instance variables. 
     3.2.5 HorizFillInTheBlank, HorizFillInTheBlankView, SimpleMinded-Controller 
     These three classes make up a FillInTheBlank that is displayed horizontally instead of vertically. They are used in the FormFilloutView. 
     3.2.6 Template 
     Template is used by BlockParams to get the question/default answer pairs. The instance variables for Template are: 
     text: the string that the user edits to create the question/default answer pairs. The resulting array is returned to BlockParams. 
     3.2.7 ValueHolder 
     ValueHolder is used to store the value of the currently selected button (e.g., 1=sine, 2=square, 3=triangle in parameter view 168 in FIG. 14). When the valueHolder receives the accept message from the formFilloutController, it sends that value to be stored in blockParams. The instance variables for ValueHolder are: 
     value: the label of the currently selected button. 
     acceptBlock: the BlockContext evaluated by the valueHolder upon receiving the accept message. 
     3.3 Additional Support Classes 
     The block editor has three additional support classes which deal with XY-scrolling and aligning the BlockEditor view on a grid. 
     3.3.1 XAxisScrollController 
     XAxisScrollController represents control for scrolling using an x-axis scroll bar. It is a subclass of ScrollController which creates an x-axis scroll bar. The x-axis scroll bar is controlled in a manner analogous to the y-axis scroll bar. The instance variables for XAxisScrollController are: 
     xScrollBar: inside white, the outer rectangle. 
     xMarker: inside gray, the inner rectangle. 
     xSavedArea: the area the xScrollBar overlaps, restored whenever the xScrollBar is hidden. 
     3.3.2 GriddedTopView 
     GriddedTopView forces the BlockEditor view to always be aligned on a 6×6 grid. This is done by modifying the method getFrame. It eliminates the problem of moving or collapsing and reopening a block editor and being unable to draw straight lines. GriddedTopView has no instance variables. 
     3.3.3 GriddedTopViewController 
     GriddedTopViewController modifies the blueButton messages &#34;close&#34; and &#34;move.&#34; The change to close adds a confirmer to forestall premature closing of a block editor. The change to move forces the BlockEditor view to always align on a 6×6 grid. 
     GriddedTopViewController has no instance variables. 
     3.4 Internal Structure of the Block Editor 
     FIGS. 31 through 41 illustrate the state diagram of the Block Diagram Editor. The states of the system primarily change as a result of mouse movements and button presses. 
     Referring to the Main Control Loop State Diagram (FIG. 31), the editor is started up by issuing the Smalltalk statement: 
     BlockEditor openOn: (Universe new) 
     The block editor is started with all parameters set to their initial states. The Universe instance variables are set to: 
     
         ______________________________________                                    
blocks:            empty dictionary                                       
connections:       empty dictionary                                       
savedBlocks:       CannedBlocksList                                       
dataDisplays:      empty dictionary                                       
listIndex:         nil                                                    
onGalaxy:          false                                                  
currentGalaxy:     nil                                                    
modelPtr:          nil                                                    
______________________________________                                    
 
    
     The BlockEditor instance variables are initialized to: 
     
         ______________________________________                                    
form:             arrow cursor form                                       
tool:             nil                                                     
currentSel:       nil                                                     
______________________________________                                    
 
    
     Next, a window 100 is created as shown in FIG. 7. The entries in the resource list 106 are taken from the Universe savedBlocks dictionary. When this window is activated (by selecting it with the mouse), the &#34;Main control loop&#34; 200 (FIG. 31) takes control. When in the BlockEditor window 100 (FIG. 6), there are three areas in which mouse activity will take place: the editing pane 104, the resource list pane 106 and the title tab area 102. Moving the cursor (with the mouse) into one of these areas causes the control loop state for that area to be entered, i.e., one of &#34;Editor Pane Control Loop&#34; 201, &#34;Resource List Pane Control Loop&#34; 202 or &#34;Title Tab Control Loop&#34; 203 in FIG. 31. 
     When a mouse button is pressed, the control state is changed to the appropriate button activity state, 204, 205, 206, 207 or 208. Note that the blue button mouse activity 206 is independent of the area in which the mouse cursor is positioned. The following paragraphs describe the activities in each state. 
     3.4.1 Editor Pane Red Button Activity States 
     While in the editor pane 106, the Red Button (BLOCK 204) controls the placement of blocks and connections in the diagram. The mouse button activity for this editing is shown in FIG. 32 for the overall activity, in FIG. 32a for drawing connections, in FIG. 32b for moving blocks and FIG. 32c for moving connections. Each activity is identified as a block by a reference numeral and figure number(s). The blocks and connections are functionally identified in the drawings, and their operations are further described below. 
     3.4.1.1 Draw block at cursor point 210 (FIG. 32) 
     Drawing a block at a cursor point consists of taking the form (e.g., a rectangle) specified by DisplayBlock form and placing it at the cursor location. 
     3.4.1.2 Selecting/highlighting and deselecting/dehighlighting blocks 211, 212 (FIG. 32) 
     Block selections are identified internally by the cursor type. Selecting a block makes the cursor type (BlockEditor &#34;form&#34;) that block. Similarly, deselecting a block sets the cursor to the normal (arrow) cursor. Highlighting a block is accomplished by bit-anding the pixels of the block form with a halftone form and displaying the result. Dehighlighting a block reverts to drawing the block in its normal form. 
     3.4.1.3 Select and highlight connection 213 (FIG. 32) 
     Selecting a connection set the cursor type (BlockEditor &#34;form&#34;) to the connection. The connection is highlighted by anding the solid line representing the connection with a halftone form. 
     3.4.1.4 Draw connection 214 (FIGS. 32, 32a) 
     The draw connection state 214 is entered by a single click of the mouse button on an unconnected output. A new instance of Connection is created with the instance variables set to: 
     
         ______________________________________                                    
fromBlock:     the block containing the output                            
               just clicked on                                            
blockOutput:   the name of the output just                                
               clicked on                                                 
toBlock:       nil                                                        
blockInput:    nil                                                        
______________________________________                                    
 
    
     Also a new instance of displayConnection is created and initialized to: 
     
         ______________________________________                                    
collectionOfPoints:                                                       
                 empty list                                               
myConnection:    pointer to the just-created                              
                 Connection instance.                                     
______________________________________                                    
 
    
     A connection is constructed by moving the mouse (state 220) and clicking at desired locations (states 221, 222) to change the direction of the line. The location on the diagram of each of these boundary points is added to &#34;collectionOfPoints.&#34; 
     This process continues until an unconnected input block pad is reached (state 223) or another output or connected input pad is reached (state 224). When an unconnected input is reached, &#34;toBlock&#34; is set to the block containing the input and &#34;blockInput&#34; is set to the name of the input. The displayConnection object is added to the Universe &#34;connections&#34; dictionary. 
     3.4.1.5 Move block 216 (FIGS. 32, 32b) 
     The move block state 216 is entered when the mouse button is depressed within the cursor in a block and the cursor is moved while the button is depressed. The block is continuously redrawn following the cursor while the button is depressed (state 225). If the button is released while the cursor is in editor pane 104, the block is drawn one last time at the current cursor position (state 227), any connections to the block are redrawn (state 228) and block data base is updated to show the new position of the block by setting DisplayBlock &#34;position&#34; to the coordinates of the current mouse position. If the button is released with cursor outside the editor pane, the block is deleted (state 229) and the connections to the block are deleted (state 244). 
     3.4.1.6 Move connection 218 (FIGS. 32, 32c) 
     The move connection state 218 is entered when the cursor is depressed on a connection and the cursor moved while the button is depressed. There are two types of connection moves: moving the output end of the connection (state 230) and moving the input end of the connection (state 231). Both operate in a similar manner in that while the button remains depressed the connection line is continuously updated to follow the cursor (states 232 or 239). Where the cursor is located when the button is released determines the final state entered for moving the connection. When moving the input end of the connection, the final cursor location must be on an unused input pad (state 238) to successfully move the connection. Similarly, when moving the output end of the connection, it must terminate on an unused output pad (state 233). If the button is released with the cursor outside the editor pane, the connection is deleted (state 236). Any other termination point results in an error (state 234, 235, 237) and the connection is unchanged. 
     Once a new location has been successfully identified, the Connection instance variables &#34;fromBlock,&#34; &#34;blockOutput,&#34; &#34;toBlock&#34; and &#34;blockInput&#34; are updated to reflect the changes made. 
     3.4.2 Editor Pane Yellow Button Activity States 205 is further detailed in FIG. 33 
     While in the editor pane 106, the yellow button&#39;s control depends on where in the editor pane the cursor is. The activity is split into four possible states which depend on the mouse position and how the block editor was opened. These state transitions are: cursor inside a block (state 240), cursor inside a macro (state 241), block editor open on a macro and cursor outside a block (state 242), and block editor open on a top level diagram and cursor outside a block (state 243). 
     3.4.2.1 Block Menu Activity 
     The Block Menu Activity state 240 (FIG. 34) is entered from state 205 whenever the cursor is in the editor pane and inside a block and the yellow button is pressed. Entering this state brings up a pop-up menu 116 as shown in FIG. 13. Selecting one of these menu items enters a new state as shown in FIG. 34. Three of these states deal with processing the inputs to blocks and are further expanded in FIG. 34a. Also three of these states deal with block outputs and are further expanded in FIG. 34b. These other states are described as follows: 
     Convert block internal form to macro internal form 252 (FIG. 34): 
     A new instance of Galaxy is created with the following instance variables set to: 
     
         ______________________________________                                    
Galaxy      inputs:      set to Block inputs                              
            outputs:     set to Block outputs                             
            name:        Block name                                       
            function     nil                                              
            parameters:  nil                                              
            insideInfo:  nil                                              
______________________________________                                    
 
    
     This is followed by creating a new instance of DisplayGalaxy and copying the DisplayBlock instance variables to the DisplayGalaxy instance variables. The Universe &#34;blocks&#34; dictionary is updated by replacing the Block that was changed to the new Galaxy. 
     Invoke internal editor block 254 (FIG. 34): 
     If the Block &#34;insideInfo&#34; instance variable is not nil, then the object this variable points to is called with the message &#34;edit.&#34; It is assumed that any objects placed here know how to edit themselves. 
     Invoke parameter form fillout pane 251 (FIG. 34): 
     When the &#34;set parameters&#34; menu item is selected, the DisplayBlock &#34;parameters&#34; object (an instance of BlockParams) is given control to display and allow the user to edit the parameters. Upon &#34;accepting&#34; the modified parameters, a new list of current values is generated and stored in the Block &#34;parameters&#34; instance variable. 
     Define internal block functions 253 (FIG. 34): 
     Prompts for the name of the star routine to be called by BLOSIM when this block executes. The name of this star function is stored in the Block &#34;function&#34; instance variable. 
     Add to block 245 (FIGS. 34, 34a): 
     The cursor is changed to an input symbol and tracks the mouse until the red button is clicked inside a block (state 255). The input node is added to the ordered collection for Block &#34;inputs&#34; and DisplayBlock &#34;inputs &#34;. The DisplayBlock &#34;inputExtent&#34; is recomputed to insure sufficient size is available to display the additional input. The block is then redrawn with the additional input added (state 256). 
     Remove an input from block 246 (FIGS. 34, 34a): 
     The cursor is changed to an input symbol with a superimposed X and tracks the mouse until the red button is clicked on an input symbol (state 257). The selected input node is removed from the ordered collection for Block &#34;inputs&#34; and DisplayBlock &#34;inputs.&#34; The DisplayBlock &#34;inputExtent&#34; is recomputed to possibly reduce the size of the displayed block. The block is then redrawn with the input removed (state 258). 
     Label an input 247 (FIGS. 34, 34a): 
     The cursor is changed to the label input prompt and tracks the mouse until the red button is clicked on an input symbol (state 259). The user is prompted for a new name and the name of the symbol is changed (state 260). The name of the symbol is changed by modifying the name in the ordered collection associated with the selected input node for the Block &#34;inputs&#34; instance variable. 
     Add an output to block 248 (FIGS. 34, 34b): 
     The cursor is changed to an output symbol and tracks the mouse until the red button is clicked inside a block (state 265). The output node is added to the ordered collection for Block &#34;outputs&#34; and DisplayBlock &#34;outputs.&#34; The DisplayBlock &#34;outputExtent&#34; is recomputed to insure sufficient size is available to display the additional output. The block is then redrawn with the additional output added (state 266). 
     Remove an output from block 249 (FIGS. 34, 34b): 
     The cursor is changed to an output symbol with a superimposed X and tracks the mouse until the red button is clicked on an output symbol (state 267). The selected output node is removed from the ordered collection for Block &#34;outputs&#34; and DisplayBlock &#34;outputs.&#34; The DisplayBlock &#34;outputExtent&#34; is recomputed to possibly reduce the size of the displayed block. The block is then redrawn with the output removed (state 268). 
     Label an output 250 (FIGS. 34, 34b): 
     The cursor is changed to the label output prompt and tracks the mouse until the red button is clicked on an output symbol (state 269). The user is prompted for a new name and the name of the symbol is changed (state 270). The name of the symbol is changed by modifying the name in the ordered collection associated with the selected output node for the Block &#34;outputs&#34; instance variable. 
     3.4.2.2 Macro Menu Activity 241 (FIGS. 33, 35) 
     The macro menu activity state 241 is entered when the cursor lies within a macro block instead of a normal block. Entering this state brings up a one item pop-up menu for entering the macro. If this item is selected, a block diagram editor is invoked on a copy of the macro (state 272). After making changes to the macro with the editor, the user &#34;accepts&#34; the changes with the yellow button in the editor pane, which causes the copy of the original macro to be saved as the macro (described in the macro BlockEditor menu activity in FIG. 36). The macro block editor is then closed with the blue button pop-up entry &#34;close.&#34; 
     In invoking the block editor on the macro, the macro must first be converted to the object Universe. This is done by creating a new instance of Universe with the instance variables set to: 
     
         ______________________________________                                    
blocks:        copy of the Galaxy blocks                                  
               dictionary                                                 
connections:   copy of the Galaxy connections                             
               dictionary                                                 
dataDisplays:  dictionary of block name                                   
               in the macro                                               
savedBlocks:   CannedBlocksList                                           
listIndex:     nil                                                        
onGalaxy:      true                                                       
currentGalaxy: pointer to the current macro                               
               being expanded                                             
modelPtr:      pointer to parent Universe                                 
______________________________________                                    
 
    
     3.4.2.3 Macro BlockEditor Menu Activity 242 (FIGS. 33, 36) and BlockEditor Menu Activity 243 (FIGS. 33, 37) 
     The BlockEditor Menu Activity States 242 and the Macro BlockEditor Menu Activity States 243 are nearly identical. The &#34;Execute diagram&#34; state 285 in the BlockEditor Menu Activity (FIG. 37) is replaced with the &#34;accept&#34; 279 and &#34;cancel&#34; 280 states (FIG. 36). The activities that are common to both states 242, 243 are first described, followed by the dissimilar activities. 
     Create macro block 275 (FIGS. 36, 37, 37a): 
     Referring to FIG. 37a, the cursor is changed to a spiral (state 290) and a new instance of a Galaxy is created with instance variables (blocks, connections and ioConnections) set to nil. Blocks to be included in the macro are selected and added to the Galaxy &#34;blocks&#34; instance variable (state 292, 294). Once the selection process is complete (i.e., double click not inside a block) the connections between selected blocks are transferred to the Galaxy &#34;connections&#34; dictionary and connections between macro blocks and other blocks are transferred to the Galaxy &#34;ioConnections&#34; dictionary. The selected blocks and associated connections are deleted from the Universe &#34;blocks&#34; and &#34;connections&#34; dictionary (state 295). A name for the macro is obtained from the user (state 296) and stored in the Galaxy &#34;name&#34; instance variable. The user then positions the macro in the editor pane (state 297). The macro is then added to the Universe &#34;blocks&#34; dictionary. This operation is followed by reconnecting the connections between external blocks and the macro (state 298) and then resetting the cursor to normal mode (state 299). 
     Label block 276 (FIGS. 36, 37, 37b): 
     Referring to FIG. 37b, upon entering state 276, the cursor is changed to &#34;Label which block&#34; (state 300). A loop is entered until the user selects a block (state 301). At the prompt for the new label (state 302), the new label is read. 
     If this is the first time the block has been labeled (i.e., it is a new block), then the block parameters are prompted for. An array of strings is displayed in an editing window in which standard Smalltalk editing facilities are used to construct a list of parameters and their initial values. A simple template is used for the parameter name and default value (see Section 3.2.1). Upon completing the parameter definitions, a new instance of BlockParams is created with: 
     
         ______________________________________                                    
template:     set to the user generated list                              
displayBlock: points to the DisplayBlock in which                         
              these parameters are associated                             
______________________________________                                    
 
    
     The DisplayBlock &#34;parameters&#34; instance variable is loaded with a pointer to this instance of BlockParams. The Block &#34;parameters&#34; instance variable is loaded with the default parameter values. 
     From the new block label a new DisplayBlock &#34;labelExtent&#34; is computed. The displayBlock extent is then set to the maximum of &#34;inputExtent,&#34; &#34;outputExtent&#34; and &#34;labelExtent.&#34; The block is then redrawn at its current position. 
     Add new block 277 (FIGS. 36, 37, 37c): 
     Referring to FIG. 37c, in state 277, a new instance of Block and DisplayBlock are created with the instance variables set to the following: 
     
         ______________________________________                                    
Block     inputs:     empty ordered collection                            
          outputs:    empty ordered collection                            
          name:       nil                                                 
          function:   nil                                                 
          parameters: nil                                                 
          insideInfo: nil                                                 
DisplayBlock                                                              
          position:   nil                                                 
          form:       default rectangle                                   
          extent:     default size of block                               
          myBlock:    pointer to just                                     
                      created Block                                       
          inputs:     empty ordered collection                            
          outputs:    empty ordered collection                            
          label:      nil                                                 
          inputExtent:                                                    
                      default size of block                               
          outputExtent:                                                   
                      default size of block                               
          labelExtent:                                                    
                      default size of block                               
          parameters: nil                                                 
______________________________________                                    
 
    
     The cursor is changed to an unlabeled rectangle (state 305) and tracks the mouse until the red button is clicked. If there is no space for the block, an error message is issued and the process repeated (state 306). If there is space available for the block, it is placed at the current location (state 307) and the DisplayBlock &#34;position&#34; is set to the current cursor location. This newly created block is added to the &#34;blocks&#34; dictionary for the Universe and the DisplayBlock is added to &#34;dataDisplays&#34; dictionary for the Universe. 
     The display block form, size and appearance is determined from the number of inputs, the number of outputs and the label. The size of the form is always adjusted so that sufficient room exists for all inputs to neatly fit on the left edge of the block, all outputs to neatly fit on the right edge of the block and the label to be centered in the block. Any time the number of inputs, number of outputs or the label is changed, the DisplayBlock &#34;Extent&#34; is determined from the maximum of the &#34;inputExtent,&#34; &#34;outputExtent&#34; and &#34;labelExtent.&#34; A new DisplayBlock &#34;form&#34; is created with a rectangle drawn within it, the label properly centered and all inputs and outputs evenly spaced on the form. 
     Cancel current mode and restore arrow cursor 278 (FIGS. 36, 37): 
     In state 278, the current mode is canceled by deselecting any blocks by setting Universe &#34;listIndex&#34; to nil. The cursor is set to normal (arrow) by setting BlockEditor &#34;form&#34; to the arrow cursor. 
     Make changes since last &#34;accept&#34; permanent 279 (FIG. 36): 
     In state 279, changes to a macro are made permanent by selecting the &#34;accept&#34; yellow button Macro BlockEditor Menu item. When this action is invoked, information in the macro (Galaxy) pointed to by Universe currentGalaxy is updated to: 
     
         ______________________________________                                    
Galaxy blocks:    set to a copy of current                                
                  Universe blocks                                         
Galaxy connections:                                                       
                  set to a copy of current                                
                  Universe connections                                    
Galaxy ioConnections:                                                     
                  set to an ordered                                       
                  collection of the current                               
                  unconnected inputs and                                  
                  outputs.                                                
______________________________________                                    
 
    
     Delete the changes since the last accept 280 (FIG. 36): 
     In state 280, changes made to a macro while in a block editor can be canceled by selecting the &#34;cancel&#34; yellow button Macro BlockEditor Menu item. When this action is invoked, information in the current Universe is reset to the macro (Galaxy) information pointed to by currentGalaxy in the following manner: 
     
         ______________________________________                                    
Universe blocks:  copy of the Galaxy blocks                               
                  dictionary                                              
Universe connections:                                                     
                  copy of the Galaxy                                      
                  connections dictionary                                  
______________________________________                                    
 
    
     Display labels on inputs and outputs 281 (FIG. 36, 37): 
     In state 281, for each block in the Universe &#34;blocks&#34; dictionary, the name of each block input (from Block &#34;inputs&#34; ordered collection) and output (form Block &#34;outputs&#34; ordered collection) is displayed next to the block input and output locations on the display. 
     Redraw entire diagram 282 (FIGS. 36, 37): 
     Erases the BlockEditor pane, then displays each block in the Universe &#34;blocks&#34; dictionary followed by a display of each connection in the Universe &#34;connections&#34; dictionary. 
     Erase entire diagram 284 (FIG. 36, 37): 
     The BlockEditor pane is erased followed by setting the following Universe instance variables: 
     
         ______________________________________                                    
blocks:            empty dictionary                                       
connections:       empty dictionary                                       
dataDisplays:      empty dictionary                                       
listIndex:         nil                                                    
______________________________________                                    
 
    
     Execute the diagram 285 (FIG. 37, 38): 
     The operation of state 285 is described in Section 4.0. 
     3.4.3 Blue Button Activity 206 (FIGS. 31, 39) 
     This activity is the conventional blue button activity for Smalltalk windows. 
     3.4.4 Resource List Pane Yellow Button Activity 207 (FIGS. 31, 40) 
     Referring next to FIG. 40, when in the Resource list pane 106, pressing the yellow button menu brings up a pop-up menu. The pop-up menu has one entry in it: &#34;remove entry.&#34; Selecting this entry and releasing the mouse button will cause a selected item in the resource list to be removed. If no item is selected, then the action is ignored. Removing an item from the resource list is accomplished by deleting the selected item from the dictionary in the Universe savedBlocks instance variable. Once it is deleted, the modified list is redisplayed. 
     3.4.5 Resource List Pane Red Button Activity 
     Referring to FIG. 41, while in state 208 the red button is used to select items in the resource list for placement in the editor pane 106. When an item is selected (state 330), the following information is established: 
     
         ______________________________________                                    
Universe listIndex:                                                       
                 set to the index of the                                  
                 selected menu item                                       
BlockEditor form:                                                         
                 set to the form of the block                             
                 from DisplayBlock of the                                 
                 selected block                                           
______________________________________                                    
 
    
     Similarly, if a item is de-selected (state 332): 
     
         ______________________________________                                    
Universe listIndex:                                                       
                 set to nil                                               
BlockEditor form:                                                         
                 set to the normal (arrow)                                
                 cursor                                                   
______________________________________                                    
 
    
     The Smalltalk environment provides the basic methods needed to highlight items in the resource list (state 331). 
     4.0 COMPONENTS OF THE EXECUTION MANAGER 
     This section describes the major components of the execution manager in greater detail with reference to FIGS. 3, 3c and 4. Referring first to FIG. 3c, the execution manager consists of several major components. Beginning at &#34;execute diagram&#34; block 350, these are: 
     The diagram scanner 352--which reduces the program represented by a block diagram to a netlist of blocks and connections. 
     The netlist interpreter 354--which reads the netlist and executes its meaning. 
     The block functions 368--which implement the meaning of the blocks in a block diagram. 
     The server/display controller 362--which monitors and handles the interprocess communication from the block functions to the Smalltalk process, storing and retrieving information in display memory 86. 
     The data display objects (see FIG. 3)--which receive and display data that is channeled through the server 362 from memory 86. Although the data display objects are created and managed by the execution manager, they may alternatively be classified as components of the user interface, as shown by blocks 85, 89 and 91. 
     The diagram animator--which binds the actual execution of a block function with the display of a given block in a diagram. This function, whose operation is shown in FIG. 4, is embedded in server 362 and block 85. 
     These major components are described below. 
     4.1 The Diagram Scanner 
     The diagram scanner 352 is initiated when the &#34;execute diagram&#34; pop-up menu item is selected from the block editor&#39;s middle mouse button menu. The menu selection results in a call to the BlockEditor method or routine executeDiagram which initiates an execution cycle. First, the block diagram is checked for validity. A diagram is considered valid if all block inputs and outputs are properly connected. If all blocks are not properly connected, an error message is displayed on the screen and the execution cycle is terminated. 
     If the current diagram is valid, the execution cycle continues. At this point, the C process (which contains the netlist interpreter and the block function code) is forked as a child process of the Smalltalk process and the two interprocess communication channels (pipes) are established. One pipe 98 is used for the Smalltalk process to send information (netlist, etc.) to the C process and the other pipe 99 enables information transfers from the C process to the Smalltalk process. 
     Once the communication channels are established, the mainline of the recursive diagram scanner 352 (BlockEditor method expandMacro) is called. The term &#34;macro&#34; is used to denote a collection of connected blocks represented as a single block. The expandMacro method creates the netlist by recursively expanding the internal structure of each of the blocks in a diagram. The recursion, in effect, &#34;flattens out&#34; a sequence of possibly nested macros into a list of block functions and their connections. Since a complete block diagram can be thought of as a single block, the data structures constituting the entire block diagram are sent to expandMacro to begin the expansion. 
     The internal structure of the expandMacro method is as follows. First, each block in the internal structure of the block being expanded is examined. If it is a macro itself, a recursive call is made to expandMacro to expand its internal structure. If not, the block represents a single block function and information about the block is sent down the pipe 98 to the netlist interpreter. The information sent is the block&#39;s name (same as its label in the diagram), the block&#39;s function (a string that informs the interpreter which block function to execute on the block&#39;s behalf) and the static parameters of the block (e.g., dc offset, frequency, etc. for a sinewave generator block). 
     When all the block information for a particular level of recursion has been sent, information corresponding to the connections of the blocks (at this level of recursion) is sent to the interpreter. Each connection is described by the names (labels) of the blocks at either end (as seen on the diagram) and the labels of its input and output. The description of the connections of the current macro with the previous level in the recursion is the last information sent for the given level. 
     The keyword &#34;END&#34; is sent to the interpreter when the complete netlist for each expanded macro has been sent. When the &#34;END&#34; corresponding to the entire diagram has been sent, the netlist expansion is complete. At this point, there is a return from the original call to expandMacro and the executeDiagram method once again has control. Its last action is to call the BlockEditor method server, which will monitor communications via pipe 99 from the C process. A description of the server follows the description of the netlist interpreter and the block functions. 
     4.2 Netlist Interpreter and Block Functions 
     The netlist interpreter 354 provides the ability to execute the meaning of a netlist. It is essentially a control program that schedules, executes and monitors the execution of the block function application code. 
     The interpreter is based on the block simulation program called IBLOSIM (for Interactive BLOck SIMulator) which is built up around the block simulator (BLOSIM) program developed at U.C. Berkeley by David Messerschmitt. BLOSIM, indicated in FIG. 3c by block 356, requires that the topology and block parameters be specified at compile time. Each time a change is needed in the topology, a source code file must be edited, re-compiled and re-linked into an executable module. In contrast, IBLOSIM allows specification of the topology and parameters as a stream of ASCII text, i.e. a netlist. 
     As used in the netlist interpreter, IBLOSIM includes a module 354 which reads a stream of ASCII text describing the diagram&#39;s topology and block parameters and makes this information available to BLOSIM for establishing the required internal topology. It also includes driver modules 366 that read in and interpret parameters for each block, thus preparing function calls for the block&#39;s execution by BLOSIM. Changing the topology or parameters only requires construction of the appropriate text stream or netlist. Recompilation or relinking of a source code file to form an executable module is unnecessary. 
     The block functions 368 contain the application code for each block and are equal to &#34;stars&#34; in BLOSIM terminology. A macro (called a &#34;galaxy&#34; in BLOSIM terminology) is therefore represented by one or more block functions. More specifically, a block function is unique data space for information about a particular block and the C code that implements its functionality. The C code includes the &#34;block function driver routine&#34; and the &#34;block function routine.&#34; A listing of a typical block function appears in APPENDIX F and descriptions of the block functions available in the resource list pane 106 are contained in TABLES 1, 2 and 3. 
     The interpreter 352 reads the block name, function and connection information sent by the diagram scanner 352. The first time each block name is encountered, a block function is created by block initialization procedure 358. This procedure sets up a data field in data storage 94 for the called block function, the code for which is stored in block 368. The interpreter passes control to the corresponding block function driver routine, which is responsible for allocating the data area for this block function and reading and storing any parameters that may follow in pipe 98. When the driver exits, it returns control to the interpreter to read more block names or connection information. 
     After all the blocks in the diagram are processed, the interconnections are processed by &#34;generate connection list&#34; block 360. This procedure uses the netlist interconnect information to define data flow channels between the data fields set up in the execution data storage 94. 
     When the netlist has been completely processed, the interpreter 354 schedules and executes the application through BLOSIM 356. It continues to pass control to the various block function routines until the execution is complete. 
     Referring to FIG. 4, as the block functions execute, they may communicate, via the pipes 98 and 99, with the Smalltalk process. This is done by message server/display controller 362 (FIG. 3c), which includes interface software to communicate between the C process and the Smalltalk process. The interpreter itself sends some messages to the Smalltalk process directly. The legal data and message transfers are each described below. The action taken by the Smalltalk process upon receipt of each message is discussed in detail in the next section. 
     All current block functions request that their corresponding display block in the block diagram be set to reverse video while they execute. BLOSIM 356 notifies the message server/display controller 362 when a block function is about to commence execution, and again when it is finished. The keyword &#34;invert&#34; is sent to the Smalltalk process by each block function along with the display block&#39;s name. The server/display controller 362 channels this request to the display block code that performs the &#34;inversion.&#34; The inversion code responds by sending the block function a signal (the character `@`) that the display block has been inverted, at which point the block function continues executing. 
     An error may occur during the execution of a block function. The block function can report the error by sending the keyword &#34;error&#34; to the Smalltalk process followed by an error message. The server intercepts &#34;error&#34; and causes the message to be displayed. 
     Various block functions also report the results of an execution. These results typically take two forms. One form is a waveform (essentially as an array of elements). A block function may communicate a waveform to the Smalltalk process by sending the keyword &#34;graph&#34; down pipe 99. The server reads this and enables an appropriate data display object to read additional data from the block function, including values that parameterize the waveform data (scale factors, units, etc.) and the waveform data itself. 
     The keyword &#34;digitizer&#34; can also be used to send a waveform to the Smalltalk process. This keyword produces similar results to &#34;graph,&#34; but can be manipulated during execution to modify the acquisition window of data returned, as described above. 
     The other form is a scalar value (such as a waveform maximum value). A block function can send a scalar to the Smalltalk process by sending the keyword &#34;scalar&#34; down the pipe 99 followed by the value to display. The server/display controller 362 again reads the keyword and a data display object is caused to display the value. 
     As mentioned above, the interpreter also talks directly to the Smalltalk process. This communication is necessary to implement the animation of &#34;macro&#34; display blocks as further discussed in the next section. 
     4.3 The Server/Display Controller, the Data Display Objects and Diagram Animator 
     The server/display controller 362 (or simply &#34;server&#34;) is the portion of the Smalltalk process that handles all transmissions from the C process. As mentioned above, the server is given control when the diagram scanner has finished sending the netlist to the interpreter. The server recognizes and acts upon the following keywords: &#34;graph,&#34; &#34;scalar,&#34; &#34;error,&#34; &#34;digitizer,&#34; &#34;invert,&#34; &#34;disarm&#34; and &#34;arm&#34;. 
     The keywords &#34;invert,&#34; &#34;arm&#34; and &#34;disarm&#34; all pertain to diagram animation. The server reads the &#34;invert&#34; keyword followed by the name of the block within the block diagram that is to be set to reverse video. The BlockEditor method invertDisplayBlock performs the actual inversion. When read by the server, the keyword &#34;arm&#34; results in a call to the BlockEditor method armMacro. This keyword is also followed by the name of the block (a macro in this case) that is to be inverted. The next inversion request, from a block that is part of the internal structure of the currently-armed macro, is dealt with in a special manner by BlockEditor method invertDisplayBlock. It causes the armed macro&#39;s display block to be animated (i.e., set to reverse video). Subsequent block inversion requests, from other blocks composing the macro, are ignored by invertDisplayBlock until the &#34;disarm&#34; keyword is received by the server, causing a call to BlockEditor method disarmMacro. 
     The keywords &#34;graph,&#34; &#34;digitizer,&#34; &#34;scalar&#34; and &#34;error&#34; all pertain to data display objects, which display the various block function results to the user. In addition to recognizing these keywords, the server is responsible for creating the data display objects and channeling the data from the block functions to the data display objects. 
     As a result of the diagram execution, the server might receive the keyword &#34;graph&#34; followed by the name of the block function that wishes to have a waveform displayed. The server maintains a list of the current data display objects in display information storage 86. If no data display object by that name exists, the server creates one and gives it access to the communication channel so that it can read the waveform data. If the display object already exists, the server simply passes control to the object and does not create a new one. 
     The &#34;scalar&#34; keyword results in the same scenario as above except a scalar data display object is created and/or given control. 
     The keyword &#34;digitizer&#34; (or another keyword corresponding to a physical instrument) accesses the signal viewing function 364, described in further detail in Section 5.0. The keyword &#34;digitizer&#34; acts like &#34;graph&#34; except the data display object has a special feature: it knows how to directly access the parameters of the corresponding display block in the original block diagram. Therefore, a block can be re-parameterized and the diagram re-executed without returning to manipulate the original block diagram. 
     The &#34;error&#34; keyword differs from the other keywords in that its corresponding data display object (the &#34;errorLog&#34;) is used by the entire diagram (versus the individual block association of the other display objects). The server creates the &#34;errorLog&#34; when the first error message is encountered from any block and channels all subsequent error messages (from any block) to the &#34;errorLog.&#34; 
     4.4 Interprocess Communication Formats 
     The interprocess communication has been described in general terms in the previous sections. This section describes the data communication formats in more detail. 
     The block editor maintains the parameters for each block in a given diagram essentially as an array of strings (i.e., character arrays). The fields of the block and connection data structures that are accessed by the diagram scanner are also strings. The diagram scanner currently does no conversion of these fields. Therefore, the entire netlist is seen by the C process as a stream of ASCII text. 
     The netlist interpreter and the block functions use standard C language I/0 routines to access the Smalltalk-to-C pipe [The C fscanf(  ) function is used]. White space characters in the pipe stream are seen as delimiters by the standard I/O routines. Therefore, parameters, block names, etc. may not contain blanks, tabs, carriage returns, etc. 
     ASCII transmission of waveform data to the Smalltalk process, however, is prohibitively slow. Therefore, C-to-Smalltalk pipe communication uses binary transmission for waveform data and other numeric values [the C fwrite() function is used for binary data] and uses ASCII transmission for string data [the C fprintf() function is used for character data]. The diagram animation handshaking is also currently implemented using standard I/O routines. Interprocess signaling is an alternative that may be used. 
     An operative system as described above has successfully demonstrated execution of signal processing and data acquisition built using the block editor. Due to the use of BLOSIM, however, the multiple process, multiple language design of the Execution manager was, to some extent, expedient rather than chosen. In addition, the functionality of the Execution manager (and the Experiment Manager as a whole) is currently restricted by the BLOSIM paradigm: an execution cycle using BLOSIM is essentially a &#34;batch&#34; operation. Since the data generation capabilities and the data display capabilities of the system currently reside in separate processes, the interprocess communication of waveform and other data is necessary and represents a considerable overhead. Binary pipe communication (versus ASCII) for interprocess transfers of waveform data is used to improve performance. 
     Several design alternatives exist, however, that could result in further improved performance. For one, the display operations in the system could be performed directly by the block functions. The user interface would need to orchestrate the display, but waveform data transfers would be eliminated. Another alternative would be a single language/single process port, eliminating netlist and waveform data transmission altogether. Waveform data areas could be directly accessed by all parts of the system. 
     Additional design alternatives exist for other aspects of the Execution manager. The diagram scanner is currently activated only when a diagram is complete. Alternatively, the scanner could be active during the diagram construction phase. The netlist would thus be complete and ready for shipment or use when a diagram is executed. Along the same vein, the netlist interpreter could be replaced by an incremental compiler that emits the necessary object code as a diagram is constructed. This would eliminate the interpretation phase. Or, the interpreter could be made to execute portions of a block diagram as the user is constructing them. This would provide the user with immediate feedback at each step of the construction process. 
     4.5 Block Function Building Procedure and Example 
     The next subsection describes how the general &#34;star&#34;-building techniques described in the above-referenced Messerschmitt BLOSIM paper have been modified to create the Experiment Manager&#39;s block functions. A C-code listing of a hypothetical example block function, with comments, is provided in APPENDIX F. The example block function has one input and one output and does no processing. It shows the basic features that are common to the Experiment Manager&#39;s block functions. The last subsection briefly describes the functionality of the current Experiment Manager block functions with reference to TABLES 1, 2 and 3. 
     4.5.1 Building a Block Function 
     The stars described in the BLOSIM paper communicate values (i.e., SAMPLEs) of a single simple type (type &#34;long&#34; integer in C terminology). The definition of SAMPLE was changed, for use as a pointer in the Experiment Manager, to be a pointer to a complex structure. This allows the block functions to communicate data of essentially any type to each other. See APPENDIX E for the definition of a SAMPLE. 
     The &#34;type&#34; field of the SAMPLE data structure allows each block function to check the type of the data it receives to verify that it is as expected. The current legal values of the SAMPLEs transmitted can be of type &#34;short,&#34; &#34;long,&#34; &#34;int,&#34; &#34;float,&#34; &#34;double,&#34; &#34;char *&#34; (character string) or &#34;WAVEFORM *&#34; (pointer to a waveform) [For the definition of the WAVEFORM data structure, see file &#34;wav.h&#34; in Appendix C of &#34;Signal Processing and Display Programs&#34; manual (TEK Part No. 070-6168-00), published by Tektronix, Inc. (1986).]. 
     The stars described in the BLOSIM paper typically read from and write to standard text files (or stdin and stdout). The Experiment Manager block functions use the pipe communication scheme described in Section 4.4. These block functions access the pipes through two global filenames defined as follows: 
     extern FILE *commandFile; 
     extern FILE *responseFile; 
     where &#34;commandFile&#34; refers to the Smalltalk-to-C pipe. and &#34;responseFile&#34; refers to the C-to-Smalltalk pipe. 
     The user generated function &#34;universe&#34; in BLOSIM is replaced by the netlist interpreter 354 (FIG. 3c) which reads the topology description from the commandFile pipe. To properly handle star initialization, each star function has a star function driver routine (see &#34;star --  example&#34; in APPENDIX F). The star function driver routine takes care of reading the parameter data over the pipe and initializing the data storage area for the star. 
     The BLOSIM stars do not need to know their names. Each Experiment Manager block function, however, needs access to its name in order to communicate effectively with the user interface (reverse video animation, error logging, etc.). Therefore, each block function stores its own name in its data area when its driver routine executes. 
     Unlike the BLOSIM stars, each Experiment Manager block function calls the C function invertBlock() to request that its display block be set to reverse video. Function invertBlock() makes the reverse video request and waits for an appropriate signal from the Smalltalk process. The function is only called if the block function is about to execute its application code (e.g., create a waveform, access and process an input, etc.). 
     The BLOSIM star routines typically print error messages to stdout. Experiment Manager block functions use the special errorLog() function to report errors to the Smalltalk process. 
     4.5.2 Descriptions of Block Functions 
     The majority of the Experiment Manager&#39;s block functions perform signal processing functions. These block functions look very much like the example given in the previous section except various calls are made to a signal processing library approximately at the point indicated in the example. A brief description of these block functions is contained in TABLE 1. 
     Several of the Experiment Manager&#39;s block functions perform instrument control functions. These block functions use RS-232 communications to talk to a GPIB controller which, in turn, controls the actual instruments. A brief description of the instrument control block functions is contained in TABLE 2. 
     Several other block functions currently exist that do not fit into the above categories. These are described in TABLE 3. The Resource column of each table refers to the names given to the blocks in the resource list pane of the block editor. The Block Function column holds the actual string used to name the block function and block function driver routines. In many cases the Resource name and the Block Function name are the same. Several of the resources have multiple rows in the Inputs, Outputs and Comments columns. The different rows refer to different alternatives. For example, the &#34;add resource&#34; in TABLE 1 accepts three alternatives for its inputs and has corresponding output and comment fields. It accepts two waveforms as inputs or two scalars as inputs or a waveform as its first input and scalar as its second input. 
     5.0 SIGNAL VIEWING CONTROL 
     5.1 Functional Overview of Digitizer Control 
     Referring to FIG. 42, the system of FIG. 5 is illustrated in a functional block diagram to show digitizer, data flow and display screen operation during signal viewing control. When actuated with initial or default settings, the digitizer 74 receives an electrical signal in analog form from a device under test 76. The digitizer conventionally digitizes the analog signal and transmits raw digital data via communication path 502 to the digitizer driver 504. Path 502 comprises the three communications elements illustrated in FIG. 5. Raw digitizer data flows over the GPIB bus 66 to the transmission protocol converter 64. The raw data is transmitted over the RS-232 bus 62 to workstation 54. 
     Returning to FIG. 42, the digitizer driver converts raw data to time/voltage coordinates. Within workstation 54, programming, described in further detail below, performs a windowing transform, indicated by functional block 506, which transforms the data from time/voltage coordinates into screen coordinates. This data is then transferred as indicated by arrow 508, to a graph drawer, indicated by functional block 510. The graph drawer includes conventional graphing and CRT display control software, which causes a graphical representation of the electrical signal to be displayed in a window 512 on CRT display 56 as a waveform 514 on graticule 515. 
     Smalltalk-80 windowing and graphing software provides a capability of graphically defining a rectangular portion of a screen display. Conventionally, this software recalls from computer memory the data pertaining to the selected portion of the displayed waveform and displays such selected portion in enlarged format within window 512. The accuracy of the enlarged displayed waveform is limited, however, to the accuracy and resolution with which the electrical signal was acquired and digitized to provide waveform 514. Signal viewing control enables the user to overcome this limitation by reacquiring a new electrical signal and waveform to be displayed, by adopting rectangle 516 as specified by the user, as a desired acquisition window for controlling the digitizer to reacquire the electrical signal. 
     To do this, signal viewing control includes software, indicated by functional block 518 for establishing the location and size of the desired acquisition window. The window location is transmitted, as indicated by arrow 520, in the form of screen coordinates for the corner points of rectangle, to a windowing transform function, indicated by block 522. This windowing transform function converts rectangle 516 from the screen coordinate system to the time/voltage coordinate system of the signal, producing the acquisition window. This new window is output to the digitizer driver 504. Upon receiving the acquisition window in time/voltage coordinates, the digitizer driver calculates new digitizer settings and transmits these via communications path 524 over the GPIB bus to the digitizer. 
     Such coordinates are also input within the computer to windowing transform 506, as indicated by data flow path 526. Similarly, location and dimensions of display window 512 are input in the form of screen coordinates to the windowing transform as indicated by data flow path 528. These data are employed, as described hereinafter, in redefining the windowing transform of block 506 that is to be applied to the next set of digitized electrical signal data to be acquired. 
     Controlled by these new settings, digitizer 74 acquires a new electrical signal from the device under test, for a signal acquisition window that corresponds as closely to desired acquisition window 516 as the built-in setting options of the particular model of digitizer permit. 
     The electrical signal is acquired and digitized according to the new acquisition window. The digitized waveform is input to the workstation, being converted to time/voltage coordinates by the digitizer driver 504. The new data is processed through the windowing transform 506, as modified by the screen coordinates and time/voltage coordinates input via paths 526 and 528 and forwarded to graph drawer 510 for display on the screen. The new signal, which approximates that portion of waveform 514 within rectangle 516 but in greater detail, is then displayed in enlarged form within display window 512. The succeeding sections of this description describe the structure and operation of the preferred form of software for implementing the above-described system in greater detail. 
     5.2 Description of Digitizer Control Software 
     FIG. 43 shows a top level state diagram for the signal viewing software. This description proceeds in the same manner as the foregoing general description, commencing with a program START 530, which enters the routine at an &#34;acquire data&#34; state indicated by block 532. Once initial data is acquired, control of the program shifts to the &#34;convert data to waveform&#34; state, indicated by block 534. Blocks 532 and 534 include the functions performed by the digitizer driver 504. Following conversion, the waveform data is input to a &#34;draw graph&#34; state 536. In this state, a graphing software module causes the waveform to be displayed on display screen 56. After displaying the waveform, program control is transferred to a &#34;wait&#34; state 538. 
     In the &#34;wait&#34; state, the computer waits for the user to depress one of the three control buttons on mouse 60. If the user presses the system button, program control switches to the system menu state 540. From this state, the user can select from among several conventional graphing software functions: a reframe function 542, a move function 544, and close function 546. Operation in the system menu state 540 is conventional and therefore need not be further discussed. 
     When the user selects the choice button on the mouse, this action causes conventional software to display a choice menu, as indicated by block 548. The choices displayed in the choice menu enable the user to select from among several options, to determine the choice of a signal acquisition window to be used by the digitizer 74 in acquiring and digitizing a next electrical signal data set. 
     The first choice is the &#34;zoom in&#34; state, indicated by block 550, operation of which was discussed above with reference to FIGS. 15-19. The second choice is the &#34;zoom out&#34; state, indicated by block 552, which enables the user to enlarge the signal acquisition window by a predetermined amount. Other states that the user may select include recalling a previous window stored in computer memory 34 (block 554) and &#34;vertical&#34; and &#34;horizontal&#34; states, indicated by blocks 556 and 558, which enable the user to control the signal acquisition window in a single dimension at a time. Similarly, the user can select a trigger level for the acquisition window (block 560), select a trigger slope (block 562), or perform other acquisition-based functions as called for by the particular kind of instrument being used. 
     All of these functions return to the &#34;acquire data&#34; state 532 upon execution. The &#34;zoom in&#34; state includes a &#34;wait&#34; state 551, which operates while the user is selecting a window size for rectangle 516. The rectangle coordinates are finally established by the user depressing the third, or pointing, mouse button to indicate the desired acquisition rectangle&#39;s origin, moving the mouse while holding the third button down until the desired rectangle has been indicated, and then releasing the button. This action returns the control to the &#34;acquire data&#34; state 532. 
     Additional, conventional control functions can also be provided on the choice menu, such as cursor control (block 564), delta cursors (block 566), save/use data control (block 568), and others as will be understood by those skilled in the art. 
     FIG. 44 illustrates the &#34;acquire data&#34; state 532 in greater detail. Operation of the signal viewing program commences at START block 530. Upon startup, the first procedure is to load default settings for an initial signal acquisition window of the digitizer, as illustrated by block 570. These settings are saved by procedure 572, which inputs the settings as a first acqRect 574 into a push-down stack 576, operation of which is conventionally controlled by use of a stack pointer 578. The default settings are then input to a &#34;vertical settings&#34; state, which is illustrated in general by block 580 and in further detail in FIG. 45a. Once the vertical settings are established, program control is shifted to a &#34;horizontal settings&#34; state as shown generally in block 590 and in further detail in FIG. 46a. 
     Once the vertical and horizontal settings have been established, program control is shifted over to a &#34;get data&#34; state 600. In the &#34;get data&#34; state, the first step is a &#34;send settings&#34; procedure. In this procedure, the vertical and horizontal settings that were previously determined are sent to the digitizer via the digitizer driver, using the appropriate protocols for RS-232 and IEEE488 communications. These settings are embodied in computer-type commands formatted so as to be understood and implemented by the programmable digitizer. The digitizer responds by executing the commands and acquiring a new electrical test signal from the device under test for the signal acquisition window as specified in the settings commands. A portion of the electrical signal within the acquisition window is digitized in accordance with the settings and formatted for transmission as a digital data stream back to the computer. Next, a &#34;read data&#34; procedure causes the computer to acquire the digital data from the digitizer via the IEEE488 and RS-232 buses, with the appropriate protocol conversion being made by protocol converter 64. 
     Referring to FIG. 43, the acquired data is passed to a &#34;convert data to waveform&#34; state 534. In this state, the raw data from the digitizer, for the electrical signal acquired within the previously specified acquisition window, is transformed into a waveform data structure conforming to the requirements of the data formats required by the graphing software for displaying graphical data on display 56. Some models of digitizer return their data as an array of numbers scaled correctly to represent voltages, as well as returning information about the horizontal scale factor (time between elements), location of time 0 (or location in time of an array element), and the horizontal and vertical units of measure. For digitizers that behave in this manner, the &#34;convert to waveform&#34; procedure is not required. 
     The next step is the &#34;draw graph&#34; state 536, detailed in FIG. 43. In this state, the first procedure is an optional &#34;draw graticule&#34; procedure. This procedure draws a graph graticule 515 (FIG. 42), if required, and relabels the dimensions on the axis as necessary. The next procedure is &#34;plot data.&#34; This procedure transforms each element of the waveform in the waveform data structure created by procedure 534 from waveform coordinates to screen coordinates. The screen coordinate points for the waveform are then displayed according to applications requirements, e.g., along graticule 515, within the boundaries of window 512 on display 56. An example of this software is included in the Tektronix Plot-10™ software, which is commercially available. 
     After the new waveform is displayed, program control shifts to the &#34;wait&#34; state 538. A discussion of operation of the signal viewing software from &#34;choice menu&#34; state 548 is presented after a more detailed discussion of operation in the &#34;vertical settings&#34; and &#34;horizontal settings&#34; states. 
     5.3 Vertical and Horizontal Settings 
     Referring to FIG. 44, whenever the user specifies an acquisition rectangle 516 (FIG. 42), the computer needs to determine appropriate vertical and horizontal component settings to send to the digitizer. Any desired acquisition rectangle (AcqRect), such as rectangle 516 in FIG. 42, can be set to have a vertical component 516Y (FIG. 45b) and a horizontal component 516X(FIG. 46b). 
     A test instrument, such as a digitizer, is conventionally designed to provide a set of ordered vertical ranges, expressed in volts peak-to-peak and commonly called the range setting 602. A selected range has a center which is located relative to the origin (zero volts) by an amount of offset 604, conventionally expressed as a percentage, +or -, of vertical range. Finally, the test instrument is constrained to operate within a range of minimum and maximum offsets (minOffset 606 and maxOffset 608). An offset outside of this range would cause the range 602 to exceed the upper or lower limits of the instrument&#39;s operational capability. 
     A user of a manually-controllable test instrument typically manipulates the range and offset controls until the display &#34;looks right.&#34; This is done interactively by changing the range setting to obtain the proper size of display of the desired signal and altering the offset setting whenever a change in the range setting causes a portion of the waveform to be lost above or below the signal viewing area. This kind of interactive control cannot conveniently be performed on a programmable test instrument, because of the need to translate changes in settings into computer commands for controlling the settings. 
     The present invention eliminates this difficulty by enabling the user to graphically specify the desired acquisition window 516, having a vertical component 516Y and a horizontal component 516X. By procedures 580 (FIG. 45a) and 590 (FIG. 46a), the system can automatically determine from the desired acquisition rectangle components, the vertical and horizontal component settings for the test instrument that best fit the desired acquisition rectangle. 
     Procedure 580, shown in FIG. 45a, automatically determines the vertical settings for the test instrument that best fit the vertical component 516Y of the desired acquisition rectangle 516. The first step in the &#34;vertical settings state 580&#34; is to select from a prestored range table, a range setting, as shown by block 610. The next procedure, shown in block 612, calculates an offset value--within the limits of prestored minOffset 606 and maxOffset 608--that most nearly centers the range 602 around the acquisition rectangle&#39;s vertical component 516Y, without violating the minimum and maximum offset constraints of the instrument. The last procedure, shown in block 614, determines whether the selected range setting and calculated offset setting combine to encompass the desired acquisition rectangle vertical component 516Y. If they do not, and there remain range settings in the table to check, control is returned to block 610 and another range setting is selected and tested as described above. 
     Briefly, this procedure calls for choosing the smallest range setting in volts peak-to-peak and offset such that: 
     minOffset≦offset≦maxOffset; 
     acqRect top≦range * offset/100+range/2; and 
     acqRect bottom≧range * offset/100-range/2. 
     If no combination of range and offset are adequate, the largest range setting should be used. Additionally, the user can be notified of this condition. 
     An operative example of software implementing the &#34;vertical settings&#34; state in Smalltalk-80 language in workstation 50 appears in the program listing of APPENDIX H. APPENDIX G lists the definitions of the signal viewing variables used above and in APPENDICES H and I. APPENDIX G also includes an example of default settings for the digitizer. 
     Referring to FIG. 46a, the &#34;horizontal settings&#34; state 590 similarly determines and sets the digitizer settings for the horizontal component 516X of the desired acquisition rectangle 516. As shown in FIG. 46b, four different horizontal digitizer windows can be established around the horizontal component 516X of the acquisition rectangle. 
     The first choice is a horizontal acquisition window 616A which completely encompasses the horizontal component 516X by including the sample point at or immediately before the earliest (or left) edge of the horizontal component and the sample point at or immediately after the latest (or right) edge of the horizontal component. 
     The second choice is a window 616B that encompasses the horizontal component by including the sample point at or immediately after the earliest (or left) edge of the horizontal component and the sample point at or immediately before the latest (or right) edge of the horizontal component. 
     The third choice is a horizontal acquisition window 616C that encompasses the horizontal component by including the sample point at or immediately before the earliest (or left) edge of the horizontal component and the sample point at or immediately before the latest (or right) edge of the horizontal component. 
     The fourth choice is a window 616D that encompasses the horizontal component by including the sample point at or immediately after the earliest (or left) edge of the horizontal component and the sample point at or immediately after the latest (or right) edge of the horizontal component. 
     Referring to FIG. 46a, the acquisition window&#39;s horizontal component is expressed in terms of a number of samples corresponding to the length of the acquisition window&#39;s horizontal component 516X, and a delay, also expressed as number of samples, of the beginning of the acquisition window from the origin (time=0). In FIG. 46b, the tic-marks along the horizontal axis indicate time intervals at which the test instrument takes samples. The typical test instrument has a set of available sampling rates and both a minimum and a maximum delay, all of which are provided to the computer for use in determining the horizontal acquisition window settings for the test instrument. 
     In FIG. 46a, the first step in &#34;horizontal settings&#34; state 590 is to select a sampleRate setting, as shown by block 620, from a prestored table of such settings available to the instrument. 
     The next procedure, shown in block 622, calculates a delay setting (i.e., within the prestored limits of minDelay and maxDelay) to offset the beginning (or left) edge of the horizontal acquisition window of the digitizer with respect to the beginning (or left) edge of the desired horizontal acquisition window. This setting can be the sample immediately preceding or following the beginning of the desired horizontal component. The test used to select the exact value of delay depends upon the user&#39;s choice of horizontal component 616A, 616B, 616C or 616D. 
     Procedure 622 also calculates the total number of samples that would be produced, given the delay and sampleRate settings, and limits that number to a prestored value specifying the maximum number of samples to be taken, maxSamples. The test used to select the exact value of delay again depends on the user&#39;s choice of horizontal component 616A, 616B, 616C, or 616D. 
     The last procedure, shown by block 624, determines whether the selected sampleRate, the selected delay setting, and the calculated number of samples combine to encompass the desired acquisition rectangle horizontal component in the manner desired (i.e., window 616A, 616B, 616C, or 616D). If they do not, and there are sampleRate settings left to check in the table, control is returned to block 620 and another sampleRate setting is selected and tested, as described above. Otherwise, control is transferred back to the block 532 of the top level state shown in FIG. 43. 
     Briefly summarizing, this &#34;horizontal settings&#34; procedure calls for choosing the highest sample rate (i.e., most samples per second) such that: 
     minDelay&lt;delay&lt;maxDelay; 
     samples&lt;maxSamples; 
     acqRect left&gt;delay/sampleRate; and 
     acqRect right&lt;delay+samples/sampleRate. 
     APPENDIX I is a program listing written in Smalltalk-80 language for the &#34;horizontal settings&#34; state, implementing horizontal acquisition window 616X. APPENDIX G defines the signal viewing variables used above and in APPENDIX I. 
     5.4 Operation in the Menu Choice State 
     Referring back to FIG. 43, after an initial signal has been acquired and a corresponding waveform displayed on the display screen, and the signal viewing program is in the &#34;wait&#34; state 538, the user can invoke the choice menu (block 548) by depressing the choice button on mouse 60. 
     Referring to FIG. 16a, an initial waveform for the AM Modulation Experiment has been acquired and displayed on display 56 within window 172. The dimensions of the initial acquisition window and graticule were set in accordance with the initialization or default settings of procedure 570 (FIG. 44). When the user presses the choice button on the mouse, a procedure 548 causes menu 173 to be displayed on the screen in the location of the mouse cursor. The menu displays a set of commands available to the user, the topmost one of which is initially highlighted. The user can change commands by moving the mouse and thereby the highlight down through the list of commands. 
     Selecting the first command invokes the &#34;zoom in&#34; state, as shown in FIG. 17. The first step in the &#34;zoom in&#34; state, is a &#34;rectangle from user&#34; procedure. This procedure is a standard Smalltalk-80 routine that prompts the user to designate a rectangle on the display screen which encompasses a portion of the signal of interest to the user. The prompt is in the form of a corner symbol initially positioned within window 512 on display 56. The user can locate the corner symbol anywhere on the display screen to designate, by pushing and holding down the mouse&#39;s pointer button, an upper left hand corner of a desired acquisition window. The location of this designated corner will be interpreted with respect to the acquisition window of the currently-displayed waveform, even if the designated corner is not within the boundary of the displayed window 172. 
     Next, by moving the mouse while holding down the pointing button, the user can move the lower right corner to form rectangle 174, which is highlighted or shaded on the display. When rectangle encompasses the portion of waveform that is of interest to the user, the user releases the mouse button. The designated area is then stored, in terms of screen coordinate system, as a variable screenRect. 
     Program control is then shifted to a procedure which compares the extent of variable screenRect with an arbitrary, prestored minimum value minimumZoomExtent. If the extent of the screenRect is less than this minimum value, control is passed to the &#34;wait for button&#34; state 551 (FIG. 43) to enable the user to designate another operation. This mechanism of checking for a very small rectangle prevents activity when the pointing button is inadvertently pressed and immediately released, and when the user wishes to cancel a &#34;zoom-in&#34; operation. 
     Operation of the &#34;acquire data&#34; state, as previously described, causes a new electrical signal to be acquired by the digitizer from the device under test and a new waveform to be displayed on display 56, as shown in FIG. 17a, in a modified graticule that displays the new coordinates for acquisition rectangle 174. Because the signal is reacquired by the digitizer, the waveform displays the signal features in substantially greater detail than the corresponding signal features for the waveform in FIG. 16a. 
     Routines 538 and 548 (FIG. 43) can be actuated by the user to again invoke the choice menu 173, this time selecting the &#34;zoom out&#34; state. In this state, the acquisition rectangle used in the prior operation is expanded by a prestored expansion factor expressed as a percentage of the horizontal and vertical components. After the zoom out settings have been determined and transmitted to the digitizer and by the computer, the digitizer obtains a third electrical signal from the device under test and returns the digitized version of such signal to the computer. The computer then displays the signal, as a waveform having a coordinate system that is modified to reflect the enlarged, zoom out acquisition window. 
     Again invoking menu 173, the user can designate and recall the &#34;previous window,&#34; i.e., corresponding to the window of FIG. 16a. This procedure sets the acquisition rectangle, acqRect, equal to the last one stored in the stack 576, as shown in FIG. 44. A new waveform is then acquired from the device under test by the digitizer for the previous window. Essentially the same signal features are displayed but the waveforms are not necessarily identical. They can vary in both magnitude and shape and in delay position along the horizontal axis. This is because the new waveform is not merely a replay of data previously stored for the prior waveform but is a waveform for a signal newly acquired by the digitizer within the same acquisition window. This feature of the invention enables multiple tests of the same signal features to be run repeatedly, e.g., for comparative analysis. 
     The choice menu (state 548) can also be invoked to select the &#34;horiz&#34; procedure. The &#34;horiz&#34; procedure causes the test system to obtain a test signal within a signal acquisition window which has the same vertical component as the prior window, but has a horizontal component that is greatly extended in both the negative and positive directions relative to the signal feature shown. Selection of the &#34;vert&#34; command in menu 173 performs essentially the same expansion as &#34;horiz&#34; but in the vertical dimension. 
     From the foregoing description, it should be apparent to those skilled in the art that other programmable, two-dimensional signal acquisition instruments, such as a spectrum analyzer, can be similarly controlled. The same principles can also be applied to the control of programmable stimulus-type instruments, as summarized below. 
     5.5 Stimulus Instrument Control 
     Stimulus-producing test instruments (those producing electrical, mechanical, acoustical, etc. signals) often have more than one setting required to define their operation. When a combination of settings dimensions can be presented as a multi-dimensional graph, the settings thus represented may be adjusted simultaneously. 
     This multi-dimensional control is achieved by representing the values of the various settings as a single point in the multi-dimensional space. Control over the various settings is achieved by adjusting the position of a representation of that point in the space. An example of such control is presented in the following Power Supply Control description, FIGS. 47 and 48, and APPENDIX J. 
     Another form of graphical control involves presentation of some prototypical signal with &#34;adjustment points&#34; graphically depicted. Each adjustment point controls a single parameter of the stimulus signal with immediate graphical feedback of the overall effect. FIG. 49 shows application of such method of control to a programmable waveform generator. 
     5.5.1 Power Supply Control 
     FIG. 47 demonstrates control over a power supply as an example of a stimulus-producing test instrument. Power supplies are typically controlled in terms of maximum voltage and current limits. These limits must be set by the user within the operating region for the particular power supply being used. Information about the operating region is typically provided to the user in the form of numbers defining upper and lower current and voltage capabilities of the power supply. The user must then keep these numbers in mind, or look them up, when setting the current and voltage limits of the instrument for an experiment. 
     In this example of the invention, these features are displayed for the positive power supply section of a Tektronix PS5010 power supply in a two-dimensional graph 700 representing current range linearly in the x dimension and voltage range linearly in the y dimension. The graph&#39;s dimensions are established to contain the power supply&#39;s operating region. (An additional 5% expansion is depicted for viewing convenience but is not necessary.) The darkened gray area 702 represents the actual operating region of the power supply. The shape of the operating region happens to be L-shaped for this particular power supply but need not be. Other models of power supply commonly have a triangularly shaped operating region. 
     The power supply&#39;s combined operating point 704, composed of the voltage setting and current setting operating points (i.e., positions on their respective axes), is constrained to be within this region. A horizontal line 706 extends from the combined operating point toward the graph&#39;s voltage axis (where current is zero) to the y-axis graticule 708. A vertical line 710 extends from the combined operating point toward the graph&#39;s x axis (where voltage is zero) to the x-axis graticule 712. These lines serve to delineate the level or operating point of each power supply setting. 
     Settings are often combined mathematically to produce a value of additional interest. By providing a two-dimensional representation, not only can the individual linear dimensions be represented, but their combined effect can also be shown. In this example, the power (in watts) provided by the instrument is the product of the voltage and current settings, and is shown by the intersection of the two lines at the combined operating point. 
     A digital readout 714 of voltage, current, and power is provided in the upper right corner of the graph to facilitate precise control. The placement of this readout is arbitrary. For example, the voltage readout may be displayed attached to the voltage line in some way, e.g., to the left in the graticule area. The current readout may be displayed attached to the current line, e.g., centered and to the right. The power readout might be attached to the intersection of the operating point lines. 
     User control is implemented by power supply control software diagrammed in FIG. 48 and listed in part in APPENDIX J. When this routine is invoked (START block 718), the first procedure is &#34;draw graph&#34; 720, as explained above. Shifting to a &#34;wait&#34; state 722, the user controls the power supply by moving a cursor (by activating a mouse, joystick, or other two-dimensional graphic input device) within the constraint region 702. Depressing the selector or position button adjusts the operating point (block 724) in a manner depending on the position of the cursor. In a preferred implementation, the cursor will then jump to: 
     1) the center point of the voltage line 706 (block 726), 
     2) the combined operating point 704 (block 728), or 
     3) the center point of the current line 710 (block 730), 
     depending upon which was closest when the selector button was depressed. In a variation of this interface, small targets might be attached to the lines&#39; mid-points and to the combined operating point. The user would select the desired type of interaction by moving the cursor near the appropriate target before depressing the selector button. 
     Once the cursor is attached to one of these points, moving the cursor will change: 
     a) the position of the voltage operating point, if 1) above, without modifying the current setting 
     b) the position of the combined voltage and current operating point if 2) above, 
     c) the position of the current operating point, if 3) above, without modifying the voltage setting. APPENDIX J lists the method for selecting among points 704, 706 and 710, and the method of adjustment upon selecting the combined operating point 704. 
     In a simplified implementation, the cursor can be made to always jump immediately to the combined operating point, thus denying independent setting of voltage or current operating points. 
     Once the desired settings are established, they are converted to power supply control commands by routine 732. Three ways of dealing with the resulting power supply settings are reasonable: 
     1) sending the voltage and current operating points to the power supply as a user slides the lines within the display, 
     2) sending the operating points only after the user has positioned the new combined operating point, or 
     3) holding the operating points for later setting by some other part of a larger instrument system. 
     As used in the BLOCK DIAGRAM EDITOR SYSTEM, the third alternative is preferred for making initial settings, followed by use of the second alternative to enable interactive control during execution of an experiment. 
     A choice menu (block 734) may also be implemented to facilitate operation of the power supply. As shown in FIG. 48, choices can include &#34;zooming in&#34; on a user-designated subsection of the operating region to provide finer placement of the operating points and, thus, finer control. A &#34;zoom out&#34; function can be provided to undo the effects of a &#34;zoom in&#34; function. A &#34;previous setting&#34; choice can restore the previous combined operating point from a stack of operating points saved as settings were adjusted. A &#34;power on&#34; and a &#34;power off&#34; choice may be provided for turning the supply&#39;s output switch on and off. Further choice menu items may be implemented for directly setting operating points for specific applications (e.g., for logic families: &#34;TTL&#34; (5 V, maximum current); &#34;ECL&#34; (-5.2 V, maximum current)). 
     5.5.2 Signal Generator Control 
     Another form of graphical control involves presentation of some prototypical signal with &#34;setting points&#34; graphically depicted. Each adjustment point controls a single operating point of the stimulus signal in two dimensions with immediate graphical feedback of the overall effect. This form of control is to be distinguished from systems, the Macintosh music systems, for example, which use &#34;sliders&#34; to establish setting values (one dimension each) by positioning each slider along a graticule and adopting the position of each as one parameter of a waveform to be generated. The waveform, however, is not displayed and graphically manipulated by movement of the sliders in such systems. This form of graphical control also differs from a known cursor tracking system for &#34;drawing&#34; a waveform to be &#34;played&#34; by the system. The latter system converts screen points of a waveform drawn by the user into amplitude samples and passes the samples through a digital-to-analog converter to produce an analog signal closely approximating the user-drawn waveform. 
     FIG. 49 shows a user interface to a signal generator (such as the Tektronix FG5010). A two-dimensional graph 750 displays a waveform 752. A pop-up-menu 754 is used to specify which waveform type (sine, square, or triangle) is to be generated. This selection is &#34;digital&#34; in nature: only one of a set of choices is available, with no intermediate forms. In the displayed example, the &#34;triangle&#34; waveform has been chosen. A graphical representation of the waveform is displayed with rectangular targets over points representative of the waveform&#39;s operating points: target 756 for peak-to-peak amplitude; target 758 for dc offset; target 760 for percent waveform symmetry; and target 762 for period. In this example, the operating points are adjusted by moving a cursor into (or near) a particular target, depressing a selection button on the mouse to select the nearest target and, while the button is depressed, moving the mouse to move the selected target. As the target is moved, the displayed representation of the signal generator&#39;s output waveform is adjusted to illustrate the change. The actual operating point values may be displayed in a read-out window 764. As in the power supply example, the operating points are constrained by the design of the instrument. In this example, adjustment simply stops when these limits are reached (i.e., continued movement of the mouse produces no effect). 
     When an operating point, such as frequency, may be adjusted over several orders of magnitude (e.g., 0.002 Hz to 20 MHz in the FG5010), two different techniques are used to illustrate the effect on the displayed waveform. Small or slow movements cause the signal representation to change, allowing the operating point to be established with great precision. When large or fast movements of the positioning device are detected, the period graticule 766 adjusts, rather than the signal representation. By pushing the operating point target, the user causes the graticule to adjust, achieving the same effect: the representation of the output waveform is properly displayed with respect to the graph. 
     Having illustrated and described the principles of our invention in a preferred embodiment with an operative example thereof, it will be appreciated by those skilled in the art that the invention may be modified in arrangement and detail without departing from such principles. 
     
                                           TABLE 1                                 
__________________________________________________________________________
Signal Processing block functions                                         
Resource                                                                  
      Block Function                                                      
              Inputs       Outputs     Parameters                         
                                                Comments                  
__________________________________________________________________________
add   add     1. waveform  1. waveform none     The input waveforms are   
              2. waveform                       added element-by-element. 
                                                2                         
              1. waveform  1. waveform          The scalar is added to    
                                                each                      
              2. scalar                         element of the input      
                                                waveform.                 
              1. scalar    1. scalar            The input scalars are     
                                                added.                    
              2. scalar                                                   
diff  diffe   1. waveform  1. waveform 1. impulse                         
                                                The input waveform is     
                                       response length                    
                                                differentiated.           
div   div     1. waveform  1. waveform none     Waveform 1 is divided by  
              2. waveform                       waveform 2 on an          
                                                element-by-               
                                                element basis.            
              1. waveform  1. waveform          Each element of the       
                                                input                     
              2. scalar                         waveform is divided by    
                                                the                       
                                                scalar.                   
              1. scalar    1. scalar            Scalar 1 is divided by    
                                                scalar 2.                 
              2. scalar                                                   
integrate                                                                 
      integ   1. waveform  1. waveform none     The input waveform is     
                                                integrated.               
mult  mult    1. waveform  1. waveform none     The input waveforms are   
              2. waveform                       multiplied                
                                                element-by-element.       
              1. waveform  1. waveform          Each element of the       
                                                input                     
              2. scalar                         waveform is multiplied by 
                                                the                       
                                                scalar.                   
              1. scalar    1. scalar            The input scalars are     
              2. scalar                         multiplied.               
polar polars  1. real waveform                                            
                           1. magnitude waveform                          
                                       1. phase units                     
                                                The block function        
                                                performs                  
              2. imaginary waveform                                       
                           2. phase waveform                              
                                       2. wrapping                        
                                                rectangular to polar      
                                                coordinate                
                                       3. delay conversion of the input   
                                                waveforms.                
range minmaxm 1. waveform  1. scalar   none     The block function        
                                                outputs the               
                                                maximum waveform value    
                                                minus the minimum         
                                                waveform                  
                                                value.                    
rfft  rffts   1. time domain waveform                                     
                           1. real waveform                               
                                       none     An fft is performed on    
                                                the                       
                           2. imaginary waveform                          
                                                input time domain         
                                                waveform.                 
sine  sinew   none         1. waveform 1. duration units                  
                                                A sinewave is generated.  
                                       2. duration                        
                                       3. amplitude                       
                                       4. frequency                       
                                       5. phase                           
                                       6. dc offset                       
sub   sub     1. waveform  1. waveform none     Waveform 2 is subtracted  
                                                from                      
              2. waveform                       waveform 1 on an          
                                                element-by-               
                                                element basis.            
              1. waveform  1. waveform          The scalar is subtracted  
                                                from                      
              2. scalar                         each element of the       
                                                waveform.                 
              1. scalar    1. scalar            Scalar 2 is subtracted    
                                                from                      
              2. scalar                         scalar 1.                 
__________________________________________________________________________
 
    
     
                                           TABLE 2                                 
__________________________________________________________________________
Instrument Control block functions                                        
     Block                                                                
Resource                                                                  
     Function                                                             
          Instrument Controlled                                           
                     Inputs     Outputs    Parameters                     
                                                    Comments              
__________________________________________________________________________
ps5010                                                                    
     ps5010                                                               
          Tektronix PS 5010                                               
                     none       1. an integer &#34;signal&#34;                    
                                           1. negative                    
                                                    This block function   
          Programmable Power    indicating the power                      
                                           voltage  allows GPIB control   
          Supply                supply has received                       
                                           2. negative                    
                                                    of the power supply.  
                                its parameters and                        
                                           current                        
                                its output is on.                         
                                           3. positive voltage            
                                           4. positive current            
fg5010A                                                                   
     Afg5010                                                              
          Tektronix FG 5010                                               
                     none       1. an integer &#34;signal&#34;                    
                                           1. waveform type               
                                                    This block function   
          Programmable          indicating the                            
                                           2. peak-to-peak                
                                                    allows GPIB control   
          20MHz Function        function generator                        
                                           3. frequency                   
                                                    of a function         
          Generator             has been   4. DC offset                   
                                                    generator.            
                                parameterized and                         
                                           5. % symmetry                  
                                output is on.                             
fg5010B                                                                   
     Bfg5010                                                              
          same as above                                                   
                     same as above                                        
                                same as above                             
                                           same as above                  
                                                    same as above         
7d20A                                                                     
     A7d20                                                                
          Tektronix 7D20                                                  
                     1. an integer &#34;signal&#34;                               
                                1. waveform                               
                                           1. start time                  
                                                    This block function   
          Programmable                                                    
                     indicating that a     2. lowest voltage              
                                                    allows GPIB control   
          Digitizer  waveform can be       3. duration                    
                                                    of a digitizer.       
                     acquired by the       4. voltage range               
                     digitizer.            5. trigger level               
                                           6. trigger slope               
                                           7. channel                     
                                           8. signal maximum              
                                           9. signal minimum              
                                           10. output on-off              
7d20B                                                                     
     B7d20                                                                
          same as above                                                   
                     same as above                                        
                                same as above                             
                                           same as above                  
                                                    same as               
__________________________________________________________________________
                                                    above                 
 
    
     
                                           TABLE 3                                 
__________________________________________________________________________
Miscellaneous block functions                                             
Resource                                                                  
        Block Function                                                    
                Inputs     Outputs    Parameters                          
                                             Comments                     
__________________________________________________________________________
amModulator                                                               
        amModulator                                                       
                1. an interger &#34;signal&#34;                                   
                           1. an integer &#34;signal&#34;                         
                                      none   This block function is used  
                                             for                          
                2. an integer &#34;signal&#34;       synchronization purposes. It 
                                             only                         
                3. an integer &#34;signal&#34;       creates an output signal     
                                             when it has                  
                                             seen a signal on each of its 
                                             3 inputs.                    
                                             In our examples the input    
                                             signals                      
                                             come from 2 function         
                                             generator block              
                                             functions and 1 power supply 
                                             block                        
                                             function.                    
constant                                                                  
        constant                                                          
                none       1. scalar  1. a value                          
                                             This block function outputs  
                                             the value                    
                                             supplied as its parameter.   
fork    fork    1. waveform                                               
                           1. waveform                                    
                                      none   This block function outputs  
                                             2                            
                           2. waveform       identical copies of its      
                                             input.                       
                1. scalar  1. scalar                                      
                           2. scalar                                      
graph   waveprint                                                         
                1. waveform                                               
                           none       none   This block function sends a  
                                             waveform                     
                                             (on the C-to-Smalltalk pipe) 
                                             to the                       
                                             Smalltalk process to be      
                                             graphed.                     
scalar  scalar  1. scalar  none       none   This block function sends a  
                                             scalar                       
                                             value (on the C-to-Smalltalk 
                                             pipe) to                     
                                             the Smalltalk process to be  
                                             displayed.                   
sink    sink    1. a SAMPLE                                               
                           none       none   This block function discards 
                                             any                          
                                             input it receives.           
__________________________________________________________________________
 
    
     
                       TABLE 4                                                     
______________________________________                                    
Extended Block Editor Menu Functions                                      
______________________________________                                    
label    change a label on a block                                        
undo     undo the last operation                                          
copy     place a copy of a selected object into a save buffer             
paste    place a copy of the save buffer on the diagram                   
flip     reverse a block on the diagram (inputs and outputs               
         move to opposite sides of the block)                             
rotate   rotate the block by 90 degrees                                   
commit   replace the current saved block diagram with the                 
         current diagram                                                  
cancel   replace the current block diagram with the saved                 
         block diagram                                                    
show labels                                                               
         toggle for displaying labels on the block inputs and             
         outputs.                                                         
build macro                                                               
         build a macro from selected parts on the diagram                 
clear    delete the current block diagram and clear the                   
         editting window                                                  
repaint  repaint the editor pane                                          
save     Save the diagram                                                 
load     Read in a saved block diagram                                    
execute  Begin execution of the the diagram                               
______________________________________                                    
 ##SPC1##