JPS6393007A - Program type control method and apparatus for emulation of state diagram of equipment or process and for control of operating condition thereof - Google Patents

Abstract

(57) [Abstract] This bulletin contains application data before electronic filing, so abstract data is not recorded.

Description

DETAILED DESCRIPTION OF THE INVENTION [Industrial Application] The present invention relates to a programmable control device for emulating a state diagram of a device or process and for controlling operating conditions, and to a method of using the control device. Involved.

Apparatus and Method 2 According to the Invention Can be used as a programmable control apparatus and method for processing finite state application programs for controlling the operating state of machines and/or processes.

In the margins below [Prior Art and Problems to be Solved by the Invention] Around the beginning of the 1960s, programmable control devices were developed into relay control systems using electromagnetic relays to control the operation of various industrial machines or processes. It has come to take its place. These programmable controllers were designed to include relay circuits, which were actually programs in computers. The relay circuit designs emulated by these programmable controllers were called ladder diagrams because of their general appearance. These ladder diagrams have demonstrated excellent functionality in designing combinatorial logic control problems in which outputs and operations are directly dependent on human power states or conditions. However, in the case of sequential control where the control operation is time-dependent, the lag diagram method has the drawbacks of being cumbersome, difficult to design, and extremely difficult to discover failures. For a discussion of these issues, see Lloyd, "Graphical Function Chart Programming of Programmable Control Devices," Control Engineering (August 1985).

To emulate these Lagu diagrams,
Programmers are arranging long lists of pool expressions in the form of software commands. Each command controls an internal or external signal. Debugging or finding faults in such systems usually requires finding an unexpected condition and intuitively searching back for some or all combinations of factors that give rise to this condition. Ta.

In addition, in a control device using this ladder diagram,
The drawback is that all changes in the system must be recorded in order to determine the cause of unpredictable conditions. Meeting this requirement required an unusually large amount of memory, making it extremely difficult to search for what was needed from the stored data.

Furthermore, these lag diagram control devices are cumbersome to program. Lag diagrams, by their very nature, are difficult to understand, and the software commands that emulate ladder diagrams have been structured so that they do not follow the same logic and sequence as ladder diagrams. Mechanical, design, and manufacturing engineers who were not familiar with ladder diagrams could not easily develop control systems for their machines or processes; in fact, these engineers relied on professional control engineers. The control system had to be programmed.

Meanwhile, in an effort to simplify programmable control devices, systems have been developed that allow engineers to emulate "state diagrams" using high-level languages. A state diagram is a graphical representation of an operating state or the conditions that change the status of an operating state in a machine or process. When represented in diagram form, a state diagram is given as a series of nodes with connecting arcs. In this case, each node represents a particular operating state, and each connecting arc is
It represents a condition or transition function that changes the status of a state. These state diagrams are easy to understand and design for the average engineer. However, systems that emulate these state diagrams are difficult to program and debug, and their operating efficiency is very low, so they cannot properly perform multitasking operations.

Drummond US Patent 4,56
An example of such a system is shown in No. 2,529. That is, this patent discusses a method and apparatus for controlling the operating state of a machine or process using "state logic variables." A "state logic variable" uniquely gives the operating state of each machine or process. This "state logic variable" gives one of two values: true or false. True means the state is active, false means inactive. The operation of Dormont's system in this manner was very similar to a ladder diagram controller, but there were some problems.

First, all finite-state application programs need to be critically scanned in order for Dormont's system to properly handle the RB IIN physical variables. To evaluate the status of a particular operating state of a machine or process, Dormont's system required evaluation of each statement in the application program to determine which state logic variables were currently active. Second, it was necessary to remember all changes in the system in order to determine the causes of unpredictable changes in the system. For this reason, a large amount of information had to be stored in a large portion of the memory, and therefore it was not possible to store it as an easily recognizable pattern so that failures could be discovered.

Third, programming Dormont's controller to emulate the state diagram was a tedious process. The language given to Dormont's patent was structured so that state diagrams could not be easily translated into program code. This was due to the inability to group conditional statements that give the status of "state logic variables" into specific areas of program code. Furthermore, almost every statement in the code states whether a condition exists or not.
or to determine whether an action should be performed;
Required evaluation of "state logical variables".

Therefore, it was necessary to use a lot of extra code just to perform a simple function.

Finally, the operating efficiency of the system was very poor because evaluating the status of state logic variables required scanning every statement in a finite state application program. For this reason, it has been almost impossible to operate the system with multitasking. That is, there was insufficient time to quickly switch between a series of operational tasks. Further, Dormont does not provide a method or structure suitable for controlling multiple operational task tracks simultaneously.

In view of this situation, the present invention reduces or eliminates the drawbacks of the above-described conventional methods, and provides a control method and device that can be quickly and freely used by many engineers engaged in control, manufacturing, and design. The aim is to.

Margin below [Explanation of Terms] Next, terms will be explained in advance so that the nature of the present invention described in this specification can be fully understood.

1. "Operating state" means a particular combination of conditions and operations that exist over a finite time interval in a machine or process. Only a subset of signals or values that are relevant to a machine or process are specifically defined. The "operating state" of a machine or process is the particular task or subset of tasks currently being performed by the machine or process.

2. "Control device" means a device that provides control over a process or machine or activity, including means for identifying "operating conditions".

For this reason, the control device must be constantly aware of changes in machine or process values and conditions.

3. "Program state" means a particular block of one or more statements of program code used to evaluate, maintain, and control "operating state."

4. The term "machine" or "process" means a system that progresses in real time from one particular operating state to the next. The next operating state is always controlled by a signal from the controller, but such a signal is not generated until a set of conditions occur in the operating mode of the system.

5. The term "multitasking operation" refers to a method of executing individual programs asynchronously on one control device such that all programs are in execution at the same time in relation to each other.

[Means for solving problems]

One representative form of the present invention is a programmable control device that emulates one or more state diagrams and controls at least one operating state of a machine or process, the device comprising: (a) means for executing an application program consisting of a plurality of blocks of statements, each of the blocks of statements corresponding to one of the operating states of the machine or process, and further comprising at least some of the blocks; consists of one or more compound statements and corresponding actions to be taken by the machine or process when in an active state, specifying the execution of the next of said blocks, and at least some of said blocks are defining said actions to be taken differently than in the case of a block, said application program corresponding to each of said one or more state diagrams;
means for executing the application program, comprising one or more program loops, each of the program loops comprising at least one of the blocks;
and (b) means for enabling at least one of said program loops to be active for execution thereof;
(c) means for enabling only one of said blocks to be active and executed at any one time point in said at least active program loop; A programmable controller is provided comprising means for executing the compound statement of the active block in a loop to control the sequence of execution of the blocks and the operation of the machine or process.

Another exemplary embodiment of the present invention is a method of using a programmable controller to emulate one or more state diagrams and to control the operating state of at least one machine or process. (a) executing an application program consisting of a plurality of blocks of statements, each of said blocks of statements corresponding to one of the operating states of said machine or process; Some of the following are the executed blocks,
consisting of one or more compound statements specifying an action to be taken during a corresponding operating state by a machine or process, at least some of said blocks specifying said action to be taken different from other blocks; said application program represents each of said one or more state diagrams by a program loop comprising at least one of said blocks; (b) at least one of said program loops is activated and executed; enabling and allowing only one of said blocks to be active and executed at any one time point of said at least one active program loop;
and (c) executing each of said active blocks of each of said active program loops to control the execution sequence of said blocks and thereby control the operation of said machine or process. A method of using a programmable controller is provided.

Briefly summarizing the preferred embodiment of the present invention, a programmable controller is provided that controls the operating state of at least one machine or process and emulates one or more state diagrams. This controller executes an application-style program consisting of blocks of statements. Each of these blocks of statements, when executed, is a program state that corresponds to one of the operating states of the machine or process. Each block of these statements includes the next block of executed statements, and
Defining the actions taken during a corresponding operating state by a machine or process.

Program states are organized into one or more program loops that provide independent sequential control over the entire machine or process, or over subsections of the machine or process.

Each program loop emulates a state diagram.

The controller can activate more than one program loop at the same time, but each program loop can only activate one of its program states. A pointer is provided for each active program loop to maintain track of active program loops and associated active program states. This pointer stores the identifier of the active program state or the starting address of the active program state. Additionally, this pointer includes an identifier indicating within which active program loop a particular program state is located. The task table allows the controller to perform several active program loops asynchronously and also determines the sequence of execution of the active program loops. The task table is further configured to maintain a track of program loops and program states that are active in the order and sequence in which each program state progresses.

Also provided are methods and apparatus that facilitate "debugging" finite state application programs. Furthermore, means are provided for recording information regarding the activity of each active program state. In particular, the controller traces the order and occurrence history of each program state and one or more conditions responsive to each occurrence of the program state.

It also enables programmers to evaluate recorded information.
Display means are also provided.

Of particular importance, the present invention allows control, manufacturing, or design engineers more freedom in designing high-level application programs that represent state diagrams. The invention also offers special design advantages. That is,
A programmer can organize all program statements that pertain to a particular operating state into a contiguous segment of program code or block of statements, and so that none of the statements pertains to any other operating state. . In this way, the programmer can partition all of the various conditions that depend on each operating state without worrying about other operating states. This procedure eliminates ``state logical variables'' and facilitates programming techniques in organized, structured formants. Furthermore,
Program loops that represent the structure of an overall state diagram are easily designed into code by simply combining partitioned code, such as with "conversional go-to statements."

The present invention operates more efficiently than conventional methods because it is not necessary to scan all the statements in an application program every time it is necessary to control the operation of a particular state. In fact, only statements of a particular program state that are relevant to the operating state are scanned.

This approach allows the controller to perform processing operations very quickly and allows the invention to perform many tasks simultaneously.
Enables more efficient processing. Further, in preferred embodiments of the invention, a task table is provided that keeps track of many sequences of tasks that are performed simultaneously and/or determines the order in which each sequence of tasks is performed.

Finally, since the application program is designed with program state, it is much easier to accurately locate unexpected conditions in the program. Means are also provided for recording the occurrence of each program state and for recording one or more conditions depending on the transition that occurs from one program state to another. This allows the analyst to quickly determine the location and cause of unexpected conditions by analyzing the representation of each occurrence of a program state, and by analyzing the condition or conditions that give rise to a transition. It becomes possible.

〔Example〕

FIG. 1 illustrates a programmable controller and computer program forming a programmable controller 10 that emulates a state diagram.

1 of the memory portion 10A of this programmable control device 10
4 stores a finite state application program. The mathematical and logical functions of this finite state application program (“application program”) are performed by a central processing unit (rcPUJ) 70. A set of task tables or pointers 68 keeps track of active program loops. Trace table 7
2 contains a temporary history of the application program's activities. The programmable controller includes a debug monitor 74 that allows the user to easily locate errors in the application program. The trace table 72, task table 68, and debug monitor 74 are all stored in the memory IOA.
is stored in Other operating system software is stored at 76 that controls many features of the programmable controller.

A terminal 80 is provided, which allows the user of the control device to program application programs and debug the system at terminal 80.

FIG. 1 shows a programmable controller 10 connected to a machine or process, such as an elevator 12. This programmable control device 10 emulates 14 application programs to control the operation of the elevator 12. A finite state application program is a high-level program that represents a state diagram (see Figure 2 (
a)).

These state diagrams are open representations of the operating state of a particular controlled machine or process. A programmer can program a machine or process represented by a state diagram by first programming a finite-state application program and then processing this program with a control device to determine the order in which each task or operation performed by the machine or process occurs. control the sequence,
By emulating and controlling,.

The programmable control device 10 has a simple purpose of monitoring, evaluating and controlling the operation of the elevator 12. Elevator 12 is comprised of motor 16, pulley 20, and elevator compartment 18. The basic principle of this elevator is that only one operating state of the elevator can be activated at any time.

The operating status of this elevator is rstoppedJ, rG
oingupJ or rGotng downJ.

A button 22 in the elevator compartment 18 causes the elevator to change from one operating state to another. For example, close the rUpJ button and press rDown
n When the J button is opened, the elevator compartment 18 will rise.

``If you close the Down J button and open the rUpj button, the elevator compartment 18 will descend.
. When the rUpJ and rDownJ buttons are both opened, or when the rUpJ and rDownJ buttons are both closed, the elevator compartment 18 stops. FIG. 2(a) shows a state diagram or diagram of operating states and conditions when changing from one state to another. In particular, the state diagram is a series of nodes 24, 2
Arcs 30 and 32 connecting these with 6 and 28
, 34 and 36. Each node provides a particular operating state, and each connecting arc represents a condition or transition function that changes the status of the particular state.

In particular, the state diagram in FIG. 2(a) shows that rGoing
upJ, rstoppedJ, and rGoin
Nodes 24 and 2 represent the operational state of gdown J.
6, and 28. The conditions that give the status of a state are the arc connectors 30, 32, 34, and 36 between the nodes. Each arc itself represents a condition and treatment set.

If you turn off the rUpJ button and turn on the rDownJ button, the elevator 18 will descend.

Arc 30 has switch conditions and operations 38.

When the rUpJ and rDownJ buttons are turned on or off together, the elevator compartment 18 stops. ” The remainder of the conditions and operation become clear from FIG. 2a.

An application program representing the state diagram of FIG. 2(a) is as follows.

rGoing upJ.

Turn on the rUpJ motor.

Turn off the rUpJ button and turn off the r Down J button, or turn on the rUpJ button and press r Down
n If you turn on the J button, proceed to rstoppedJ.

rStopped J.

If the Break 0ne rUpJ button is on and the rDown J button is off, proceed to rGoing UpJ.

If the rUpJ button is off and the rDownJ button is on, proceed to rGoing DownJ.

When the rGoing DownJ rDownJ motor on rup button is off and the rDownJ button is off, or when the rUpJ button is on and the rDoivn J button is on, proceed to rStopped J.

The three blocks of statements above are called program states, each block corresponding to a particular operating state of the elevator 12 and a particular node in the state diagram (FIG. 2(a)). Each of the program states has a state-limiting statement, rGoing upJ.

rStopped J or rGoing Dow
nJ, which signals to the controller the end of one program state and the beginning of a new program state. The state-limiting statements above involve a sequence of none or one or more compound statements that effect a transition from the currently processing or active program state to another program state. It can be caused. A compound statement consists of a conditional part and an action part. When the condition part is satisfied, the action part is executed and a transition to a new program state occurs. In other words, the compound statement determines what the next executed program state will be and what type of action the machine or process will take during the corresponding active state. All three program states mentioned above have compound statements rGo To J, which provide a shift operation of the program state to another program state.

By grouping all statements related to a particular operating state into one continuous code section, the system scans these statements to evaluate the current operating state of the machine or process, and Determining whether a particular set of conditions are satisfied to initiate a new operating state. Dormont's system, already described, is used to determine the current operating state, i.e. which "state logical variables" have a true value, and then to initiate the operating state. Although all statements in an application program are evaluated to determine whether a particular condition is satisfied, the present invention works much more efficiently due to structural differences in the program. ,.

FIGS. 2(b) and 2(c) are diagrams of the program state. Block 48 in both figures is the program BrGoing.
Block 50 represents the code sequence for the program state Br5topped J, and block 52 represents the code sequence for the program state rGoing DownJ. Arcs 54, 56, 58, and 60
(Fig. 2b and 2 parts) is the arc 30° 32 of the state diagram, 3
4, and 36 (FIG. 2(a)). Arcs 54, 56, 58, and 60 above illustrate how the flow of activities in an application program is influenced by compound statements.

The arc 58 in FIG. 2(b) is the conditional part of the compound statement: r rLIpJ button is on and r Down J button is off, or rUpJ button is on and r Down
When "When the J button is also on, proceed to rStopped J" is true, this indicates that a transition occurs from the rGoing UpJ program state to the rStopped J program state. Similarly, the conditional part of the compound statement in the arc 60 is: r If the rUpJ button is off and the rDoivnJ button is on, go to rGoing DownJ, then go from the program state of rstopped J to rG
This indicates that a transition to the oing DownJ program state occurs.

These program-like g rGoing UpJ.

rStopped J, and rGoing Dow
By connecting nJ, a program loop is logically formed.

This program loop 46 controls the sequence of operations performed by the elevator 12. In a preferred embodiment of the invention, a program loop can have one active program state at any one time. In this way, it is possible for the controller to keep track of the sequential processing of individual arrays of tasks. The program loop 46 of FIG. 2(b) emulates the state diagram (see FIG. 2a) and has the characteristics of having only one program state active at any one time to control the elevator 12. (i.e., the elevator compartment can simply either go up, go down, or stop at any one point in time).

If the machine is more complex, a single program loop may simply represent a specific, independent subsection of the machine or process. When an application program has one program loop, the control device controls a part of the machine or process. Typically, multiple program loops are required to independently control several parts of a complex machine or process. FIG. 2(d) shows a more complex machine represented by a plurality of interconnected state diagrams 62, 64 and 66.

Each state diagram depicts the sequential control arrangement of one section of a machine or process. The present invention emulates these state diagrams by processing program loops (also called multitasking) that control three virtual subsections of the machine. A particular program loop can be processed independently of the rest of the program loops, or can be processed independently of the rest of the program loops (6 in Figure 2(d)).
3, 65°67, and 69) and “handshake”
and can be synchronized. This multi-tasking capability of the control unit is well known to programmers and is therefore not a problem for programmers when designing their application programs.

To facilitate the execution of program states within program loops, the preferred embodiment provides a program pointer for each active program loop. Third
As shown in Figure (a), this program loop pointer 90 has fields 92 and 94 that hold simple variables. The first simple variable 92 is the identifier of the currently active program loop. The second simple variable 94 is the identifier of the active program state or the starting address of the active program state in memory. These program state addresses or identifiers can be easily converted to other addresses or identifiers.

The remaining portion 96 of pointer 90 contains other less important status information related to the program loop. The actual purpose of the program pointer 90 is to keep track of the program state that is active at any point in time within a particular program loop.

When a particular program loop becomes active, program loop pointer 90 is associated with the loop. As various program states become active within the program loop, the simple variable 94 becomes overwritten with the address or identifier of the new program state. This program loop pointer 90 allows one program loop to "handshake" or integrate with a second program loop to determine how far the system has processed through the second program loop. ,. Additionally, this program loop pointer 90 is accessed by terminal 80 to allow the programmer to note those sequences in which program conditions occur.

In the preferred embodiment, all program loop pointers are stored in the task table of FIG. 3(b), which is stored in memory 10A (FIG. 1).

This task table primarily functions to allow processing of all of several program loops at the same time. The program loop pointers are packed into the task table such that all non-empty pointers are at the beginning of the table, and arranged in numerical order of their respective program loop identifiers (92 in Figure 3(a)). be done. Referring to FIG. 3(b), the first program loop pointer 100 in the task table has the lowest loop identifier (eg, 1) and therefore the highest priority for processing.

Pointer 102 has the second lowest loop identifier in the table and is processed second. pointer 104
is the third lowest loop identifier (e.g. 3) associated with this
, which is processed third. Pointer 106 has the next lowest identifier (eg, 34) and is processed fourth.

Additionally, associated with the task table is a task table register 112 (FIG. 3(c)), which points to the program loop pointer currently executing the active program loop. To scan and process program loops in the task table, the controller writes the address of the active program loop pointer 90 to the task table register 112.

When the controller executes a program loop associated with pointer 100, only one block of program state statements associated with program loop 100 is executed or activated. Next, ;Ill? ]Il device processes the next program loop (e.g. 2), and only one program state related thereto is processed. The controller repeats this procedure for all active program loops.

The task table register has a zero associated with the loop identifier and points to the program loop pointer 108;
The controller is alerted that it has reached an empty program loop pointer. When this occurs, the operating system of the controller points the task table register to the top of the original task table and executes the next program state of the first program loop in the table. This procedure is an endless process unless there is a terminal interrupt or the like.

Because only a few lines of program code are processed for each program state, the control system is able to jump from one program loop to another very quickly. In this way, the controller will behave as if it were processing all multiple program loops or tasks at the same time.

To indicate that a program loop has been activated, the control unit assigns a program loop pointer to the activated program loop and assigns a new program loop pointer (
90) in Figure 3(a) is placed in the task table.

The system uses a new program loop identifier (Figure 3(a)
) and adapts the program loop pointer to its normal position in the task table corresponding to this evaluated value. For example, if the number is greater than or equal to 34, the new pointer will be at record 10 of the task table.
8 (Fig. 3(b)). However, if the new program loop's identifier is between 3 and 34, program loop pointer 108 is exchanged with pointer 106, and the new program loop pointer is 1.
That's what people say in 06.

In this embodiment of the task table, there can be up to 31 program loop pointers in the task table, so the contents of the task table must be evaluated to ensure that there is space available for new pointers. The controller will notify the programmer when the task table becomes full or when a task table overflow condition occurs.

Turning now to FIG. 4, a logical diagram of the trace table is shown, which is stored in the controller's memory portion 10A and is part of the debug monitor 74 (FIG. 1). A trace table is conceptually a linear table in memory stored as a wrap around an "endless tape" storage buffer. This trace table 82 operates exactly like an airplane flight recorder.

This kind of flight recorder is a "play bank" that records what happened to the plane immediately before it "crashed."
It's something I'll show you. Similarly, a trace table records what happened to a machine or process just before it failed. In other words, playback is used to find out exactly what decisions were made by the controller immediately before the system error occurred.

The trace table register 84 is the trace table register 84.
Stores the address of the last recorded location in,. FIG. 4 shows register 84 pointing to record 79 as the last location to be filled in trace table 82. Once the trace table 86 is filled, the system continues to store new data and write them over old data.

The following describes in detail a preferred embodiment that handles finite state application programs and facilitates diagnosing unexpected conditions in finite state application programs.

Section 5.6, 7, 8, 9. lO, 11, 12, and 13
The figure is a flowchart representing a subroutine that, in conjunction with a programmable controller, controls the processing of an application program. In particular, in FIG. 5, subroutine 5TART PROGRAM initializes various pointers and tables of the programmable controller.

In FIG. 6, the subroutine FIR5T 0PER
ATOR evaluates the first command in program state. In Figure 7, ADVANCED C0DEPOI
NTER controls the standard application program pointer (Pcode pointer). This pointer points to the address in memory of the current statement that the control unit is executing. Figure 8 ADVANCE TASK
TABLE specifies which record the task register 7' indicates. In FIG. 9, the subroutine NEXT 0PERATOR evaluates all statements in the program state except the first statement. Go To in FIG. 10 and 5TART in FIG. 11 shift the processing within one program loop to another program loop. GO5UBRO in Figure 12
UTINE and RETIJRN of FIG. 13 affect the order of processing of program states within a particular program loop.

FIG. 5 shows a flow block diagram for the 5TART PROGRAM. This routine initializes the program controller. In particular, at block 122, the controller initializes the task table (Figure 4b), the task table register (Figure 4C), and the Pcode pointer. The task table is initialized with a program loop pointer that points to the first active program loop in memory. Additionally, the program loop pointer is initialized to the first program state of that program loop. The Pcode pointer is initialized with the starting address of the first active program state. The system is now in a state where it processes the first active loop. At block 124, the system executes subroutine FIR
3T Call 0PERATOR to evaluate the first statement pointed to by the P code pointer.

The block diagram in Figure 6 shows the subroutine FIR5TOPER.
This shows ATOR. At block 128, the controller analyzes the type of statement pointed to by the P-code pointer. The first statement so encountered is either a "state" statement, a "pause state" statement, or a "break state" statement. A state statement is a program state delimiter that symbolizes the beginning of a program state. A pause statement causes a pause or stop of an active program loop and also causes the start of the next active program loop in the task table. A break state statement causes the entire system to halt execution and returns to the monitor to inform the programmer that the controller has ceased processing. Once the status statement is obtained at 130, the controller executes the subroutine ADVANCEP-CODf! at 132. Call POINTER to advance the Pcode pointer to the next statement address in the program state. If the statement encountered in the program state is 134 pause state statements, the system uses 116 5UBROUTINE
ADVANCE TASK TABLE REGISTE
Call R to proceed to the next active program loop. If the statement so encountered is of the break state type, subroutine GOTOMONITO of 138
R is called.

GOTOMONITOR applies a message to the terminal to notify the user of the programmable controller that a break statement has been obtained and execution of the program code has been halted.

Looking at FIG. 7, the subroutine ADVANCE P-C
A detailed block diagram of ODEPOINTER is shown.

At block 142, the Pcode pointer is incremented to the next statement in the active program state.

The control '4B device is 144 subroutines NEXT 0PE
Process the next statement by calling RATOR.

FIRST 0PERATOR encounters the pause state statement (Figure 6), subroutine ADVA
The REGISTER is called to NCETASKT. The purpose of this subroutine is to initialize the processing of the next program loop. FIG. 8 shows a detailed block diagram of this subroutine. block 148
Then the task table register is advanced to the address of the next program loop pointer for that task table. Subroutine FIR5T 0PERATIOI? is called at block 150 to process the first active program state of the next program loop in the task table.
.

When the state form statement is obtained at 128 (Figure 6)
, the control device uses the subprogram ADVANCEP-COD
Proceed to E POINTER 142 (Figure 8). As described above, this subroutine advances the P-code pointer to the next statement in the program state and calls 144 tes sub) Lt - CHI NEXT 0PERATOR.

The first statement in program state is FIRSTOP
FIG. 9 is a schematic block diagram of the subroutine NEXT 0PERTOR, which is always evaluated by ERATOH. This subroutine is intended for evaluating any kind of statement in program state other than first-duration statements. At block 154,
The controller reads the next command pointed to by the P code pointer. If the next statement that occurs is either a state statement, a pause state statement, or a break state statement, the control unit is 15817)7'/RATIA ADVANCE TA
Call SK TABLEREG 15TER (Figure 9). If the statement encountered is not one of the three above, the controller evaluates whether the statement is a 160 Go To statement. If the statement is a Go TO statement, subroutine GOTO is called at 162. This subroutine is detailed below.

If the statement is not a Go TO statement, the controller proceeds to block 164 and determines whether the statement is a start statement. If this statement is a start statement, the controller is 1
66 subroutine 5TAL? Call T. This subroutine will be explained shortly.

If the above statement is not a start statement,
The controller proceeds to block 168 where the statement G
O Determine whether it is a subroutine statement. If this statement is a GO subroutine statement, then the control unit 170 subroutine Go 5U
BI? Call 0UTINE. This statement is G
o If it is not a subroutine statement, the controller will determine whether the statement is a 172 Return statement. If it is Re
For a turn statement, the controller calls subroutine RETURN at 174.

This statement is Go To, 5tart, G
.

If it is not of type 5ubroutine or Return, the controller proceeds to block 174 and evaluates the statement as a normal control statement. Normal control statements do not affect the status of program state. In other words, the program state continues processing without jumping to a new program state of the same or a different program loop.

On the other hand, statement type, Go To, 5tar
t, G.

5ubroutine, and Return all potentially affect the status of the program state and/or the corresponding active program loop. As explained at the outset, these forms of statements are called compound statements and provide the status of a particular program state if a certain set of conditions is met. When the controller evaluates 176 successful control statements (Figure 9), this is the subroutine: /ADVANCE P-C
Call ODE POINTER to evaluate the next statement in the active program state.

FIG. 10 is a block diagram of a subroutine called Go TO. This Go To subroutine evaluates the current status of the operating state, determines whether a particular set of conditions are satisfied, and if so, returns to the next program loop as directed by the task table. , proceed to processing. This Go TO effectively causes one program loop to begin control over the next program loop indicated by the task table. In other words, a particular sequence of independent tasks can influence the operation of other sequences of independent tasks if a particular set of machine or process conditions are satisfied.

In block 182 of FIG. 10, the controller is connected to the GOT.

Evaluate the conditional part of the statement. If GOT.

If the statement set of conditions is not satisfied, the control unit 184 subroutine ADVANCE P-CO
Call DEPOTNTER. If the conditions are met, the controller executes subroutine 5TORE 186
5TOI? Call Y.

This 5TORE ll5TORY stores the "decision point" address and program loop identifier in the trace table (third
Figure). This decision point is the address of the Go TO statement because the program state caused the status to change. In other words, the GOTO statement makes a "determination" to change the status of the program state. At block 188, the next program loop pointer in the task table is updated such that simple variable 94 (Figure 3a) points to the address of the new program state. Next, block 190 (7) ADVANCE TASK TABLE
REGISTER is called, which updates the task table's registers so that it points to the task table's next program loop pointer.

FIG. 11 is a block diagram of a subroutine called 5TART. The purpose of this 5TART is to initialize the processing of any program loop specified in advance in the application program. On the other hand, the Go TO subroutine simply proceeds to process the next program loop stored in the task table.

In block 194 of FIG. 11, the conditional portion of the start statement is evaluated. If the condition is true, the controller
Execute OINTER. If this condition is not true, the controller proceeds to block 198 and executes subroutine 5TO.
Process REll5TORY. This 5TORE old 5TOIIY stores the address of the start statement and the program loop identifier containing the start statement. At block 200, the controller determines whether a particular program loop is currently active and stored in the task table. If this program loop is already active, in block 202 the controller writes over the address currently stored in the simple variable 94 of the program loop pointer (FIG. 4a) with the address of the new program state to be activated. It's crowded. However, when a program loop is not currently active, the system slots a new program loop pointer into the task table at 204. This new program loop pointer is placed in the normal position in the task table that corresponds to the numerical value of the program loop's identifier.

At block 206, the address of the new program state is written to the program loop pointer. Block 2
At 02, the control'II device activates the subroutine ADV so that a particular program loop can begin processing.
Call ANCED P-CODEPOINTER.

FIG. 12 is a block diagram showing GO5UBROUTINE. This GO5UBROUTINE affects the processing of the active program loop. In particular, this subroutine causes one program state within a program loop to activate a new program state only within the same program loop. On the other hand, subroutine Go
To (Figure 1O) and 5TART (Figure 11) initiated control over a new program loop.

Referring to block 210 of FIG. 10, the conditional portion of the GO subroutine statement is evaluated.

If the condition is not met, the controller calls subroutine ADVANCE P-CODE POINTER 214. However, when the conditional statement is satisfied,
The control device is 216 subroutines 5TORE llll5
Call TORY.

This subroutine stores decision points and program loop identifiers in a trace table. At block 218, the controller buffers in memory the current address stored in the P-code pointer, the currently active program state, and the status of the condition flag. The condition flag stores whether the evaluated condition is satisfied or not.2
It is a hexadecimal variable. At block 220, the address of the new program state is written to simple variable 94 of program loop pointer 90 (Figure 4a), and this address is also stored in the P code pointer. The controller calls subroutine FIRST 0PERATOR at 220 to begin activity in a new program state.

FIG. 13 shows the subroutine RETUl? FIG. 2 is a detailed block diagram of N. The purpose of this ReTurn statement is to
The purpose is to return the control device to the programmed state called GO5UBROUTINE. In other words, GO
When the particular program state called by SUBROUT INE (FIG. 12) completes execution, the controller returns control to the old program state that was active when GO5UBROUTINB was called. Is this GO5UBI? The values of pointers and registers stored by 0UTINE are required to be restored.

Referring to FIG. 13 at block 224, the controller
Evaluate the conditional part of the urn statement. If this condition is not satisfied, the control device
Call TER. However, if the condition is satisfied, the controller returns 5TORE lll5T at block 222.
Call ORY.

This routine saves the address of the decision point and the loop identifier in which it occurred. At block 230, the controller restores the value saved in block 218 of GO5UBRO[ITINE. ADVANCEP of block 232
- CODE POINTER is called next to continue processing the old program state.

Figures 14, 15, 16, 17, and 18 are block diagrams of programs that facilitate debugging of application programs. In particular, FIG. 14 shows the subroutines Go To, 5TART, GO5UBROtl.
5TORIli HIST is a utility program for updating the trace table (Figure 4) with information stored by TINE and RETURN.
It is a block diagram of ORY. The remaining figures show utility programs that allow the programmer, based on his own commands, to view information stored in trace tables, task tables, or the program state itself. In particular, FIG. 15 shows a DISPLAY
FIG. 2 is a block diagram of a program called HISTORY. 16 and 17 respectively show subroutine D.
ISPLAY LINE and DISPLAY PROGR
AM 5TATf! It is. These routines are used to display all of the statements in a particular program state, and to indicate which statements within the program state were decision points or changed the status of the program state. Figures 18 and 19
The diagrams show DISPLAY LOOP and FOUN, respectively.
D-- LOOP, these display the active program loops associated with the active program state stored in the task table.

5TORE HISTORY is called every time the status of the program state changes. This 5TORE H
ISTORY is the subroutine Go TO (first of 186
0 figure), GOStlBROUTINE (12th of 216
), 5TART (Figure 11 of 198), and R
ETURN (228, Figure 13). As mentioned above, 5TORE HISTORY stores in a trace table the address of a decision point in an active program state and the loop identifier in which this decision point occurred.

In block 236 of FIG. 14, the address stored in trace table pointer 84 (FIG. 3) is evaluated. If the address pointed to by the trace table pointer is at the end of the trace table, the trace table pointer is automatically set at block 240 to the beginning of the trace table. This step causes the l-race table to appear as if it were an endless loop (see Figure 4). Regardless of whether the pointer is at the end of the trace table, the address of the decision point will be written to the record pointed to by the trace table pointer. Additionally, at block 244, the controller also stores the active program loop identifier in a record. At block 248, the controller returns to the calling subroutine.

The subroutine old 5PLAYllll5TQRY allows the programmer to evaluate the history of program states that occurred during the processing of an application program.
. The programmer starts this program when he wants to see a display of what has been stored by the trace table. This subroutine displays the contents of the trace table of the two-axis table. In that case, the horizontal axis gives the identifier of the program loop and the program state that is executed or defined differently than that occurring in the active program loop. The vertical axis represents the sequential order of program states and program loops. DISPLAY HTSTORY
is a subroutine initialized directly by the user at terminal 80 (FIG. 1). This DISPLAY lll5TOR
Y's normal fu.

The following is an example of the lint output.

DISPLAY 115TORY Note that the command DISPLAY HISTORY is first shown on the screen. Second, the top section provides "active program state" and "active program loop." The two leaps below each of these statements are actifs.

shows the program state and active program loop. The right side of the screen shows a short comment for each line displayed. The last resulting program state is shown on line O. Program state 2 and program loop 2 were the last active ones. The initial active program state and the program loop it was in is shown on line 7. Line 8 indicates the end of the trace table.

When an unexpected condition occurs in the flow of an application program, the programmer can easily identify in which program state the unexpected condition occurred by looking at the sequence of program states that occurred during processing. Can be done. For example, assume that program state 200 should not have occurred during an application program. In this case, it appears that an unexpected condition must have occurred in program state 81 that caused the status of program state 1 to change to program state 8200. The programmer calls DISPLAY LINE (FIG. 16) to display program state 1 and this state 1.
It is possible to examine more closely the conditions under which the shape 1200 was changed. We will discuss this program shortly.

Here, DISPLAYHI in block 252 of FIG.
When viewing STORY, the controller prints the header that appeared at the top of the screen as shown above. Next, at block 254, a copy of the trace table and a copy of the trace table printer are stored in a buffer. By storing these trace tables and trace table pointers in a buffer, DISPLA
A snapshot of what was stored in the trace table when the Y_HISTORY request was made is obtained. The reason for such a step is that the trace table is a dynamically changing table, constantly updated, and only the status of the table at the time the request is made is required for analysis. There is a particular thing. At block 256, the system obtains the address stored in the trace table pointer of the last record stored. At block 258, the controller evaluates this address to determine whether the buffer is empty.
. If it is empty, a termination statement is printed and the control returns to its original processing at block 260. If not empty, the trace table is evaluated to determine whether it has pointed to the end of the buffer in block 262;
. When the pointer is at the end of the buffer, the trace table pointer is set to the beginning of the buffer at block 264. Control bags in this way? iH:! , processing the contents of the trace table as if it were an endless loop. Regardless of whether the trace table pointer is at the end of the buffer, the loop identifier and state address are
66 buffers. In the case of placing a pre-stored program state number in one of the program state statements, the decision point address is used as the starting point. At block 268, the program state number and program loop identifier are printed in their respective columns as shown above. At block 270, the trace table pointer is incremented to the next record in the buffer, and the routine continues processing at block 258. The program repeats loop 271 until all of the program states and corresponding program loops stored in the trace table have been printed.

In the above example, the programmer knew in advance that program state 200 was not to be populated.

The programmer may also notice that unexpected conditions
We also know that it must have occurred during program state 1 on line 6 of HISTORY. By calling subroutine DISI'LAY LINE, the programmer can dissect what happened in program state 1 and determine exactly what caused the program state to change to program state 200. Can be done. DISPLAY LINE generates a list of statements in a program state and an indication of which statements within the program state were decision points or changed the status of the program state.

Now, looking at FIG. 16, we see that the subroutine DISPLAY
A detailed block diagram of LINE is shown. This program is started directly by the programmer via a call from terminal 80 (FIG. 1). At block 274, the programmer indicates which lines of the DISPLAY HISTORY printout he wishes to enlarge.

For example, he is interested in what happened from line 6 to line 5, so he expands line 6 via DISPLAYLINE. At block 274, DISPLA
The desired line number of Y HISTOPY is the variable rLin.
Cents equal to e CountJ. block 27
At 6, the controller determines whether the selected line number is within a range of valid numbers.

If not, the controller returns to its normal processing at block 278. Assuming the line number is within the valid range,
, the last data entry in the trace table is pointed to by the trace table pointer in block 280. The trace table pointer is then incremented by one at block 290. At block 292, the controller:
Determine whether the trace table pointer points to the end of the trace table buffer. If instructed,
The trace table pointer is set to the beginning of the trace table at block 292. The controller evaluates rline_countLJ to determine whether it is zero at block 294, regardless of whether the trace table pointer points to the end of the buffer.

When this r1ine countJ is zero, the desired program state is uncovered and DISPLAY
PROGRAMSTATE is called at block 296. When rlinecount J is not equal to zero, rlinecount J is decremented by l and the trace table pointer is incremented by one at block 290. The loop 301 is r 1ine countJ
becomes zero at block 296 and repeats until the indicated program state is found.

Figure 17 shows subblue + 7DISPLAY PROG
It is a detailed block diagram of RAM 5TATE. At block 304, the controller determines whether the record pointed to by the trace table pointer is empty. When empty, the system prints a statement to terminal 80 that the requested line is invalid and returns to its normal processing at 306. If the record is not empty, the controller extracts the address of the decision point from the trace table and determines the starting address for the program state at 308. At block 310, the controller prints the text of the program status. At block 312, the controller checks whether the controller has printed a "decision point" by comparing the address of the printed statement with the decision point address stored in the trace table. When printed, the statement r”DECIS
ION POINT"J is printed at block 314. If no decision point is printed, the controller advances to the next statement in the program state of block 316. At block 318, the controller prints the next statement. is a state delimiter statement or a state statement,
Determine whether it is a pause state statement or a break state statement. If any of these three statements are obtained, the controller returns to its normal processing at block 320. If none of the three statements are available, processing loops 322 until all statements in the program state have been printed.
will continue through.

FIG. 18 is a block diagram of DISPLAY LOOP.

This DISPLAY LOOP is a subroutine that displays the contents of the task table. Referring to the example screen display shown below, the loop identifiers are provided in the horizontal axis and the active program state within each of the program loops is indicated vertically below each of the program loop identifiers. The ones shown below are DISPL
This is an example of a screen display of the output of AY LOOP.

PROGRAM LOOP IDENTIFIER 12345...-3031 PROGRAMMED B IDENTIFIER In block 324 of FIG. receive. block 3
26 sets the task table register to the first program loop pointer of the task table. rloop
A variable called countJ is set to zero at block 328. rLoop count at block 330
J is incremented by one. At this time, the control device
Determine whether countJ is equal to the maximum number of program loops + the number that can be stored in the text table. If this condition is true, the controller returns to its original processing at block 334.

When the loop count is not equal to the maximum number of program loops plus one, the controller obtains the loop identifier from the associated task table pointer. At block 338, the loop identifier is checked to determine if it is equal to zero. If this program loop identifier is equal to zero, the system returns to its normal processing at block 340. If the program loop identifier is not equal to zero, the controller determines whether the loop identifier is "equal to 1oop countJ" at block 342.
. If the loop identifier is equal to r 1oop countJ, block 340 calls subroutine LOOP
FOllND is called. If the program loop identifier is not equal to ``1oopcount_J'', the controller advances across the screen to the next loop position at 348.

rLoop countJ is incremented by one at block 350, and the blocks after block 328 are repeated until there are no more active program loops in the task table.

FIG. 19 is a detailed block diagram of the subroutine FOUND LOOP. At block 354, the starting address of the active program state stored in the program pointer is extracted from the previously stored statement of the program state. At block 356, the task table pointer is incremented to the next program loop pointer;
The control device uses the routine DISPLAY of 364 in FIG.
Return to LOOP.

Although the present invention has been described above using preferred embodiments by way of illustration, the present invention is not limited thereto. Many variations and modifications can be made without departing from the spirit and scope of the invention, as will be apparent to those skilled in the art. For example, the invention may be implemented through several different software techniques and any number of different software languages.

[Brief explanation of the drawing]

FIG. 1 shows a method for controlling the operation of a machine or process according to the invention
FIG. 2(a) is a state diagram showing the various operating states of the elevator and the conditions that induce transitions between the states; FIG. 2(b) is the operating state of the state diagram of FIG. 2a. A diagram of a block of statements, corresponding to
Figure 2(c) is a diagram emphasizing the structure of the program code, Figure 2(d) is a state diagram for a more complex case, and Figure 3(a)
Figure 3(b) shows the program loop pointer, Figure 3(b) shows the task table, Figure 3(c) shows the program loop pointer.
Figure 4 is a logical diagram of the trace table shown in the form of an endless loop. Figure 5 is a schematic diagram of a subroutine called 5TART PROGRAM. Figure 6 is a schematic diagram of a subroutine called FIR5T 0PERATOR. , Figure 7 shows the sub-routine ADVANCE P-CODE.
Schematic diagram of POINTER, Figure 8 shows +7”/I/--5-7ADVANCE
TASK TABLE1? A schematic diagram of EGISTER, Figure 9 shows the subroutine NEXT 0PERATOR (7
) Schematic diagram, Figure 10 is a schematic diagram of the subroutine GOTo,
Fig. 11 is a schematic diagram of subroutine 5TART, Fig. 12 is a schematic diagram of subroutine Go 5UBROUTINE, Fig. 13 is a schematic diagram of subroutine RETURN, and Fig. 14 is a schematic diagram of subroutine RETURN.
The figure is a schematic diagram of a subroutine called 5TORE HISTORY, Figure 15 is a schematic diagram of a debug routine called DISPLAY HISTORY, Figure 16 is a schematic diagram of a debug routine called DISPLAY L4NE, and Figure 17 is a schematic diagram of a debug routine called DISPLAY PROGRAM 5TAT.
A schematic diagram of the debug routine called E, Figure 18 shows the debug routine DISPLAY LOOP.
FIG. 19 is a schematic diagram of the debug routine FOUND LOOP. DESCRIPTION OF SYMBOLS 10... Program type control device, 10A... Memory part, 12... Elevator, 24, 26, 28... Nodes of state diagram, 30
, 32 , 34 , 36 , 54 , 56 , 58 ,
60... Connecting arcs of state diagram, 46 , 63 , 65 , 67 , 69 , 100...
・Program loop, 48, 50, 52...Block, 62, 64, 66...State diagram, 68...
- Task table, 70... Central processing unit, 72, 82... Trace table, 74... Debug monitor, 80... Terminal, 84, 90, 100.102.104, 106.1
08...Pointer, 108...Record, 1
12...Register, 92...Identifier.

Claims (1)

Claims: 1. A programmable control device for emulating one or more state diagrams and controlling the operating state of at least one machine or process, the device comprising: (a) a plurality of statements; means for executing an application program consisting of blocks of statements, each block of statements corresponding to one of the operating states of the machine or process, and further comprising at least some of the blocks consisting of one or more compound statements specifying execution and actions taken during a corresponding operating state by said machine or process, said actions taken being different for at least some of said blocks than for other blocks. and wherein the application program comprises one or more program loops corresponding to each of the one or more state diagrams, each of the program loops comprising at least one of the blocks. (b) means for enabling at least one of said program loops to be activated for execution thereof;
(c) means for enabling only one of said blocks to be active and executed at any one point in time of said at least active program loop; a programmable controller comprising: means for executing said compound statement of said active block within said block to control the execution sequence of said blocks and said operation of said machine or process. 2. The enabling means comprises a pointer related to the at least one active program loop storing a starting address of the active block, and the pointer comprises an identifier indicating the active program loop consisting of the active block. , the apparatus according to claim 1. 3. The enabling means comprises a pointer storing an identifier of an active program loop in relation to the at least one active program loop, and the pointer comprises an identifier indicative of an active program loop consisting of an active block. An apparatus according to claim 1. 4. storing each of the pointers associated with the at least one active program loop to facilitate multitasking of a plurality of the at least one active program loop and controlling the execution sequence of the at least one active program loop; 4. A device according to claim 2 or 3, further comprising means for: 5. The apparatus of claim 1, further comprising means for recording information indicating an active block of said statements and an execution sequence of said at least one program loop. 6. The control device comprises means for indicating a condition depending on the selection of the next block to be executed, and the means for recording the information indicates one or more of the conditions and the action taken during the corresponding operating state. 6. Apparatus according to claim 5, comprising means for storing. 7. The apparatus of claim 5 or 6, further comprising means for displaying recorded information regarding the active block and the at least one active program loop. 8. A method of using a programmed controller to emulate one or more state diagrams and to control the operating state of at least one machine or process, the method comprising: (a) an application program consisting of a block of statements; each block of statements corresponds to one of the operating states of the machine or process, and at least some of the blocks are associated with the next executed block;
one or more compound statements specifying an action to be taken by a machine or process during a corresponding operating state, at least some of said blocks specifying said action to be taken different from other blocks, and said application (b) enabling at least one of said program loops to be activated and executed; , and allowing only one of said blocks to be active and executed at any one time point in said at least one active program loop; and (c) each of said active program loops. A method of using a programmable controller comprising: executing each of said active blocks of said blocks to control the execution sequence of said blocks and thereby control the operation of said machine or process. 9. The enabling step comprises storing an identifier of the active block in a pointer associated with the at least one active program loop, and storing an identifier of the at least one active program loop consisting of active blocks. do,
The method according to claim 8. 10. The enabling step includes storing a starting address of the active block in a pointer associated with the at least one active program loop, and storing an identifier of the at least one active program loop consisting of active blocks. The method according to claim 8, comprising: 11. storing each of the pointers associated with the at least one active program loop to facilitate multitasking of a plurality of the at least one active program loop; 11. A method as claimed in claim 9 or 10, further comprising the step of controlling. 12, the active block and the at least one
9. The method of claim 8, further comprising the step of recording information indicative of an execution sequence of two active program loops. 13. The method comprises the step of indicating a condition responsive to selection of a next executed block, and the step of recording the information includes the step of indicating one or more of the conditions and the action taken during the corresponding operating state. and recording the
A method according to claim 12. 14. Displaying information recorded in the block and the at least one active program loop.
The method described in section. 15. A programmable control device for emulating one or more state diagrams and controlling the operating state of at least one machine or process, the device comprising: (a) an application program consisting of a block of statements; wherein each of said blocks of statements corresponds to one of the operating states of said machine or process, and at least some of said blocks of statements correspond to a next said executed block by said machine or process. and one or more compound statements specifying actions to be taken during an operational state, at least some blocks specifying said actions to be taken that are different from other blocks, and said application program one or more program loops corresponding to each of the state diagrams, each of the program loops consisting of at least one block of said statements; means for enabling to be executed and means for enabling only one of said blocks of statements to be active and available for execution at any one time in said active program loop; c) the enabling means comprises means for directing the at least one active program loop;
the indicating means comprises means for storing an identifier of an active block and means for storing an identifier indicative of a program loop consisting of active blocks; (e) means for facilitating multitasking of at least one program loop and controlling the execution sequence of the at least one active program loop; A programmable control device comprising means for executing said compound statement in an active block to control the execution sequence of said blocks and for controlling said action according to the operating state of a machine or process. 16, wherein said indicating means associated with said at least one active program loop comprises means for storing a starting address of an active block and means for storing an identifier indicative of at least one active program loop consisting of active program states. The apparatus according to claim 15. 17, the active block and the at least one
16. The apparatus of claim 15, further comprising means for recording information indicative of an execution sequence of two active program loops. 18. The control device comprises means for indicating a condition depending on the selection of the next block to be executed, and the information recording means stores one or more of the conditions and the action to be taken during the corresponding operating state. 18. Apparatus according to claim 17, comprising means. 19, the active block and the at least one
7. The apparatus of claim 5 or 6, further comprising means for displaying recorded information regarding two active program loops. 20. The apparatus of claim 16, further comprising means for recording information indicative of an active block of said statements and an execution sequence of said at least one program loop. 21. The control device comprises means for indicating a condition depending on the selection of the next block to be executed, and the means for recording the information stores the action taken during an operating state corresponding to one or more of the conditions. 21. The apparatus of claim 20, comprising means for: 22. The apparatus of claim 20 or 21, further comprising means for displaying recorded information regarding the active block and the at least one active program loop. 23. A method of using a programmable controller to emulate one or more state diagrams and to control the operating state of at least one machine or process, the method comprising: (a) implementing an application program consisting of blocks of statements; executing one or more blocks of statements, each of said blocks of statements corresponding to one of the operating states of said machine or process, and at least some of said blocks defining one or more next said blocks to be executed; and an action to be taken by a machine or process during a corresponding operating state, at least some of said blocks specifying said action to be taken differently from other blocks, and an application program (b) enabling at least one of the program loops to be activated and executed; and (c) the enabling step includes the step of: enabling only one block of blocks to be active and executed at any one time in the at least one active program loop; storing in a pointer; and storing an identifier in the pointer to indicate at least one active program loop consisting of an active block; (e) storing each of the plurality of active program loops to facilitate multitasking operation of a plurality of the at least one active program loop and to control the execution sequence of the at least one active program loop; A method using a programmable controller, comprising: executing the compound statement of each active block to control the sequence of execution of the blocks and the operation of a machine or process. 24. Storing the information in a pointer comprises storing a starting address of an active block and storing an identifier indicative of at least one active program loop consisting of the active block;
A method according to claim 23. 25. The method of claim 23, further comprising the step of: recording information indicative of an execution sequence of the active block of statements and the at least one active program loop. 26. The method comprises the step of indicating a condition responsive to the selection of a next block to be executed, and the step of recording said information indicates one or more said conditions and said action taken during the corresponding operating state. 26. The method of claim 25, including the step of recording. 27. The method of claim 25 or 26, further comprising the step of: displaying recorded information regarding the block and the at least one active program loop. 28. The method of claim 25 or 26, further comprising the step of: recording information indicative of the execution sequence of the active block of statements and the at least one active program loop. 29. The method comprises the step of indicating a condition responsive to the selection of a next executed block, and the step of recording said information indicates one or more said conditions and said action taken during the corresponding operating state. 29. The method of claim 28, including the step of recording. 30. The method of claim 28 or 29, further comprising the step of displaying recorded information regarding the block and the at least one active program loop. 31. A programmable control device for controlling the operating state of at least one machine or process by emulating one or more state diagrams, the device having means for executing an application program consisting of blocks of statements. and each of said blocks corresponds to one of said operating states, and at least some of said blocks correspond by a machine or process to one or more compound statements defining a next executed block. the application program comprises one or more program loops corresponding to each of the one or more state diagrams, each program loop comprising at least one of the blocks. and the programmable controller comprises operating system software, the software comprising: (a) means for enabling at least one of the program loops to be activated and executed; , comprising means for enabling only one of said blocks of statements to be active and executed at any one point in said active program loop, and (b) said enabling means comprises said at least one means for instructing one active program loop, the instructing means for storing an identifier of an active block;
(c) storing each of the indicating means to facilitate multitasking operation of a plurality of the at least one program loop; , and means for controlling the execution sequence of the at least one active program loop; (d) executing the compound statement of each of the active blocks in conjunction with the active program loop to control the execution sequence of the blocks; A programmable control device comprising means for controlling said operation according to the operating state of the machine or process. 32. Claim 32, wherein said indicating means associated with said at least one active program loop comprises means for storing a starting address of an active block and means for storing an identifier indicative of at least one active program loop consisting of active blocks. range 3rd
The device according to item 1. 33, the active block and the at least one
33. The apparatus of claim 31 or 32, further comprising means for recording information indicative of the execution sequence of two active program loops. 34, the active block and the at least one
34. The apparatus of claim 33, further comprising means for displaying recorded information regarding two active program loops. 35. Operating system software used in a programmable control device that emulates one or more state diagrams to control the operating state of at least one machine or process and that executes an application program consisting of blocks of statements. each of said blocks corresponds to one of said operating states, and at least some of said blocks include one or more compound statements defining a next executed block and a machine or process and an action taken during a corresponding operating state by the block, the application program comprising one or more program loops corresponding to each of the one or more state diagrams, each of the program loops including at least one of the blocks. (a) means for enabling at least one of said program loops to be activated and executed; and only one of said blocks of statements (b) the enabling means comprises means for directing the at least one active program loop; The instructing means comprises means for storing an identifier of an active block and means for storing an identifier indicative of a program loop consisting of active blocks, and the operating system further comprises: (c) the operating system instructing the at least one program loop; (d) means for storing each of the means for facilitating multitasking operation of a plurality of the at least one program loop and for controlling the execution sequence of the at least one active program loop; Operating system software comprising means for executing said compound statement of each of the active blocks to control the sequence of execution of said blocks and to control said operation according to the operating state of a machine or process. 36. The indicating means associated with the at least one active program loop comprises means for storing a starting address of an active block and means for storing an identifier indicative of the at least one active program loop comprising active program states. , the apparatus according to claim 35. 37, the active block and the at least one
37. Apparatus according to claim 35 or 36, further comprising means for recording information indicative of the execution sequence of two active program loops. 38. The apparatus of claim 37, further comprising means for displaying recorded information regarding the block and the at least one active program loop. 39. A method of configuring an operating system that emulates one or more state diagrams and controls the operating state of at least one machine or process, the method comprising the step of executing an application program consisting of a block of statements. and each of said blocks corresponds to one of said operational states, and at least some of said blocks are between one or more compound statements defining the next said executed block and the corresponding operational state. and wherein the application program comprises one or more program loops corresponding to each of the one or more state diagrams, each of the program loops comprising at least one of the blocks. A method of configuring,
The method includes: (a) at least one of the program loops;
may be active and executed, and only one of said blocks may be active and executed at any one point in time within said at least one active program loop. (b) the enabling step comprises storing in a pointer an identifier of an active block and an identifier indicative of at least one active program loop consisting of an active block; c) executing the compound statement of each of the active blocks in conjunction with the active program loop to control the execution sequence of the blocks and the operation of a machine or process; storing each of said pointers associated with a program loop in a storage means to facilitate multitasking operation of a plurality of said at least one active program loops and to control the execution sequence of said at least one active program loop; How to configure the operating system. 40. The step of storing information in a pointer comprises the steps of storing a starting address of an active block and storing an identifier indicative of at least one active program loop consisting of an active block. the method of. 41. The method of claim 39 or claim 40, further comprising the step of recording information indicative of an active block of the statements and an execution sequence of the at least one active program loop. 42. The method of claim 40 or 41, further comprising the step of: displaying recorded information regarding the block and the at least one active program loop. 43. A programmable control device for controlling the operating state of at least one machine or process by emulating one or more state diagrams, the device comprising: (a) an application program consisting of a block of statements; means for executing, each of said blocks of statements when executed being a program state, each of said program states corresponding to one of the operating states of said machine or process, and at least some of said blocks comprises one or more compound statements defining the next executed block and an action to be taken by the machine between the corresponding operating states, wherein at least some of the program states cause a different action to be taken. (b) enabling at least one of the program loops to be active, and only one of the blocks being active within the active program loop at any one time; Steps that make it possible to
(c) the enabling means comprises means for indicating the at least one active program loop, the indicating means comprising means for storing an identifier for an active block, and each of the pointers comprises: , having an identifier indicative of a program loop consisting of active blocks; and (d) executing the compound statement in each active block with each active program to control the execution sequence of the blocks and Alternatively, a programmable control device comprising means for controlling the operation according to the operating state of the process. 44. The means for indicating the at least one active program loop comprises means for storing a starting address of an active block and means for storing an identifier indicative of an active program loop consisting of active blocks. The device according to item 43. 45. storing each of said means for directing said at least one active program loop in a storage means to facilitate multitasking operation of a plurality of said at least one active program loop;
45. The apparatus of claim 43 or 44, further comprising means for controlling the execution sequence of two active program loops. 46. The apparatus of claim 44 or 45, further comprising means for recording information indicative of the active program state and the execution sequence of the at least one active program loop. 47. The control device comprises means for indicating a condition responsive to the selection of the next executed program state, and the means for recording said information indicates the action taken during the operating state corresponding to one or more of said conditions. 47. The apparatus of claim 46, comprising means for storing. 48. The apparatus of claim 46 or 47, further comprising means for displaying recorded information regarding the active program state and the at least one active loop. 49. A method of using a programmable controller to emulate one or more state diagrams and to control the operating state of at least one machine or process, the method comprising: (a) from a block of statements; executing an application program, each of said blocks at runtime being a program state, each of said program states corresponding to one of the operating states of said machine or process, and at least some of said blocks consists of one or more compound statements defining the next block to be executed and an action to be taken by the machine during the corresponding operating state, at least some of the blocks being different from the other blocks. defining actions to be taken differently, said application program comprising one or more program loops corresponding to each of said one or more state diagrams, each of said program loops comprising at least some of said blocks. (b) enabling at least one of the program loops to be active, and only one of the blocks is active in the at least one program at any point in time; (c) the enabling step stores a starting address of the active block in a pointer and stores an identifier of the at least one program loop with the pointer. (d) storing each of the pointers associated with the at least one active program loop to facilitate multitasking operation of a plurality of the at least one active program loop; A method of using a programmable controller comprising the steps of controlling the execution sequence of two active program loops. 50. Storing information in the pointer includes storing a starting address of an active block;
50. The method of claim 49, comprising storing an identifier indicative of an active program loop of active blocks. 51. storing pointers related to the at least one active program loop in a storage means to facilitate multitasking operation of a plurality of the at least one active program loop and to control the execution sequence of the at least one active program loop; 51. A method as claimed in claim 49 or claim 50, further comprising the step of: 52. The method of claim 49 or claim 50, further comprising the step of recording information indicative of an execution sequence of the active block and the at least one active program loop. 53, the control device comprises means for indicating a condition responsive to selection of a next block to be executed, and the step of recording said information indicates said action taken during one or more said conditions and corresponding operating state. 53. The method of claim 52, including the step of recording. 54. The method of claim 52 or claim 53, further comprising the step of: displaying recorded information regarding the active block and the at least one active program loop. 55. A programmable control device for controlling the operating state of at least one machine or process by emulating one or more state diagrams, the device comprising means for executing an application program consisting of a plurality of statements. , each of said blocks when executed is a program state, further each of said program states corresponds to one of said operating states, and at least some of said blocks define a next said executed block. the application program comprises one or more compound statements and actions taken between corresponding operational states by a machine, at least some of said blocks specifying different actions than other blocks; A programmed control device comprising: (a) one or more program loops corresponding to each of the program loops, each of the program loops comprising at least one of the blocks, the device comprising: (a) at least one of the program loops; one is active, and only one of said program states is active in said active program loop at any one time, and (b) a starting address of an active program state with respect to said at least one active program loop; A pointer that stores
at least one each consisting of an active program state
a pointer having an identifier indicating one of said active program loops; and (c) means for executing said compound statement of each of said active blocks with each of said active program loops. 56. storing each of said pointers relating to said at least one active program loop in a storage means to facilitate multitasking operation of a plurality of said at least one active program loops and execution of said at least one active program loop; Claim 54 further comprising means for controlling the sequence.
56. Apparatus according to paragraph 55. 57. The apparatus of claim 55, further comprising means for recording information indicative of the active program state and the execution sequence of the at least one active program loop. 58. The control device comprises means for indicating a condition responsive to the selection of the next executed program state, and the means for recording said information indicates one or more said conditions and said action taken during the corresponding operating state. 58. Apparatus according to claim 57, comprising means for storing. 59. The apparatus of claim 58, further comprising means for displaying recorded information regarding the program status and the at least one active program loop. 60. A method of using an operating system to emulate one or more state diagrams and control the operational state of at least one machine or process, the method comprising the steps of executing an application program consisting of a block of statements. , each of said blocks at run time is a program state, further each of said program states corresponds to one of said operating states, and at least some of said blocks define a next said executed block. comprising actions to be taken between one or more compound statements and corresponding operating states by a machine, at least some of said program states specifying actions to be taken differently from other program states;
the application program comprises one or more program loops corresponding to each of one or more state diagrams;
Each of said program loops consists of at least one of said blocks, and (a) enables at least one of said program loops to be active, and only one of said blocks is active in said program at any point in time; (b) storing an identifier of the active block in a pointer; and storing an identifier of the at least one program loop with the pointer; further comprising the step of: (c) storing each of said pointers associated with said at least one active program loop in a storage means to facilitate multitasking operation of a plurality of said at least one active program loops; A method using an operating system comprising controlling the sequence of execution of one active program loop. 61. The method according to claim 60, wherein the step of storing information in the pointer comprises the steps of storing a starting address of an active program state and storing an identifier indicating an active program loop consisting of the active program state. Method. 62. storing pointers related to the at least one active program loop in a storage means to facilitate multitasking operation of a plurality of the at least one active program loop; 62. The method of claim 60 or 61, further comprising the step of controlling. 63. The method of claim 60 or 61, further comprising the step of recording information indicating the program state and the execution sequence of activities of the program loop. 64, the control device comprising means for indicating a condition responsive to the selection of the next executed program state, and the step of recording said information comprises means for indicating the condition taken between one or more said conditions and the corresponding operating state. 64. The method of claim 63, comprising the step of recording the action. 65, a method for facilitating debugging of a finite state application program for a programmable controller, the method comprising: the finite state application program comprising one or more blocks of statements; Each block is a programmed state, each of which occurs only when one or more conditions cause the programmed state to occur;
The method includes: (a) recording each of the occurrences of each of the programmed states; (b) recording the one or more conditions that cause the occurrence of the programmed states; and (c) the steps of: debugging, comprising: displaying one or more program states and/or an order of the one or more conditions according to the occurrence of each said program state, thereby facilitating debugging of a finite state application program; How to facilitate. 66. A programmable computer that facilitates debugging of finite-state application programs, wherein the finite-state application program consists of blocks of one or more statements, each block being a program state when executed by the computer; and each of said program states occurs only when one or more conditions cause said program state to occur, further comprising: (a) means for recording said respective occurrences of each of said program states; and (b) said program state. (c) displaying the one or more program states and/or the order of occurrence of the one or more conditions that may be responsive to each of the program state occurrences; and steps to facilitate debugging of finite state application programs. 67. A programmable controller for controlling the operation of at least one device or process, the programmable controller comprising: (a) application program means using the concept of state variables; (b) reference to state variables; (c) includes monitoring means that provide the necessary support for programming languages and functions, and has debugging support means as a system service; and (c) records information for subsequent use. A programmable controller comprising means, wherein the subsequent use information comprises previous transitions that occurred as to which states were active in the system and the order of transition occurrence or activity of the previous states. 68. The programmable control device of claim 67, further comprising means for retrieving and providing information to a user. 69. The system software means comprises means for recording information indicating which logical calculation or calculations during processing of the program caused the corresponding state transition or transitions to occur. A programmable control device according to claim 67 or 68. 70, comprising one or more program loops, each corresponding to a state diagram, and at least one of said program loops being active, said system software means determining which program loops contained executed statements; 69. The programmable control device according to claim 67, further comprising means for recording information indicating whether a corresponding state transition has been caused to occur. 71. The programmable computer of claim 70, wherein each program loop has a program state corresponding to a state of a state diagram, and only one of the program states is active in each of the active program loops at a time. Control device. 72. The programmable control device according to claim 71, wherein each program loop has an identifier, and the program loop identifier of the loop in which the logical calculation has occurred is recorded in the information. 73. The program further comprises a compound statement composed of a conditional part and an action part, and the conditional part consists of one or more simple conditional calculation statements, and each of the statements satisfies a certain system condition. is true or false, and the conditional part determines whether the action included in the action part is executed or not, and further records recorded information. Claims 67 to 72 include a storage location for the simple conditional evaluation statement in a program in which a determination has been made that the conditional part of the compound statement was true. The programmable control device described. 74. When the recorded information includes a memory location in the program at which a determination was made that the conditional portion of the compound statement that changes the state activity is true, such information is read in the context of the program. Syntax rules in said program for statements specifying the information necessary to independently determine which term of which conditional part of which statement in which state caused which state-activity transition at a given time. 74. The programmable control device according to claim 73, wherein the programmable control device is provided with: 75. The recorded information includes the time at which the state activity transition occurred.
The programmable control device according to any one of items 4 to 4. 76. A programmable controller for controlling the operation of at least one device or process, the programmable controller comprising: (a) application program means using the concept of state variables; (b) reference to state variables; (c) means provided within the programming language, including monitoring means to provide the necessary support for the programming language and functionality, and having debugging support means as a system service; and (d) means for automatically advancing the program upon power-up. 77. The control device comprises means for setting the state to a break state, which means, when activated, generates a predetermined debug function, which debug function causes control to return to the monitor program portion of the operating system. The programmable control device according to any one of claims 67 to 76, wherein the programmable control device stops an application program so that it can be debugged and examined, generates a predetermined debug function, and generates a predetermined debug function. A programmable control device according to any one of the preceding claims, wherein during the processing of a program loop, the condition occurs but causes a stop that does not affect the processing of other program loops. 78, the control device comprises means for bringing the state into the stopped state, which means, when activated, causes the occurrence of a predetermined debug function, which debug function processes the program state at the point indicated by the stop statement. 77. A programmable programmable device according to any one of claims 67 to 77, wherein the stop portion is optionally conditional but does not affect the processing of other program loops. Control device. 79, each state is a program state represented in the program by a state identifier associated with a block of statements; 7
The programmable control device according to any one of items 8 to 8. 80, only one state in a state diagram can be active at a time, and this active state is indicated by the storage of a variable value indicating an active state block, which variable is assigned to indicate the activity of the state. 80. A programmable control device according to claim 79. 81. The programmable control device of claim 80, wherein the active state is indicated by storing a pointer to a state block or to an identifier for the state block. 82. Other properties selected from ``break'' or ``pause'' or other debug functions are related to the state by being encoded in a statement that is also used as a state specification statement. 82. The programmable control device according to item 81. 83. A programmable control device for controlling the operation of at least one machine or process by emulating one or more state diagrams, the device comprising: (a) an application program defining the one or more state diagrams; (b) the application program comprises a block of at least a plurality of statements, each block being a program state corresponding to a state in a state diagram;
and at least some of said blocks include one or more statements defining at least one control action to be taken during scanning of said blocks; and (c) said program comprises one or more programs corresponding to state diagrams. (d) at least one of the program loops is active and only one of the program states is active at any one time; (e) is active in each of the active program loops, and (e) enables the controller to process program statements in each active program state in each active program loop, thereby controlling the operation and state sequence of the machine or process. A programmable control device, comprising means for: 84. The need to evaluate whether any particular state is active in order to perform a state-dependent activity or to make a state-dependent determination that depends on the state's activity in the program loop in which the state-dependent statement appears. 84. A programmable control device according to claim 83, further comprising program structure means for eliminating the nature of the program. 85. The program structure means consists of rules in which all statements containing state-dependent evaluations or actions that depend on a particular state are collected in a state block for this particular state, and within one system. executes only the statements that appear in the state blocks of states that are active in the state, thereby eliminating the need to evaluate whether a particular state is active It is excluded because an active recognition and therefore also an inactivation of an action is implied, and when the statement is executed, it is excluded because an active recognition is implied by an active state. 85. The programmable control device according to claim 84. 86. A programmable control according to any one of claims 83 to 85, having a variable associated with each active program loop to store a value indicating the beginning of an active program state in this loop. Device. 87. The programmable control device according to claim 86, wherein said variable comprises a pointer that holds a start address of a state block. 88, from the first initialized variable of said variables;
taking a value in the initialized variable indicating the start of a state block of a first program to be processed, processing the first state block, and when modification is indicated by the processing of the first state block; is provided with operating system software means for advancing the program by modifying the values stored in said variable or other variables and maintaining a required record of the activity of the current state block, and the processing of the program is performed in a similar manner. 88. A programmable controller as claimed in claim 86 or claim 87, wherein the programmable control device iterates through each of the active blocks in a desired order. 89, each of said pointers is used to activate a particular program loop for subsequent processing in a known order with respect to other program rooms, and for use in debugging. 89. A programmable control device according to claim 87 or 88, comprising an identifier that allows initialization to the state block. 90. The programmable control device according to any one of claims 83 to 89, comprising boundary specifying means constituted by status statements specifying boundaries of status blocks and associating status identifiers with the status blocks. . 91. The programmable control device of claim 90, further comprising organizing means for organizing said pointers into a task table to facilitate control of said processing in said known order. 92. The programmable control device according to any one of claims 83 to 91, wherein the application program is stored as a P code executed by a P code interpreter program. 93. A programmable control device according to any one of claims 83 to 92, constructed, arranged, and operative as herein described and described with reference to the accompanying drawings. . 94. A method of controlling a system of at least one machine or process controlled by a programmable controller by emulating one or more state diagrams to control operating states of at least one machine or process, the method comprising: Where the controller uses operating system software and an application program that in turn utilizes the concept of state variables, the method includes: (a) preparing a particular transition of a state variable activity or activation of a particular state; The control device is
(b) providing debugging support that initiates one or more predetermined debugging functions without user intervention and without requiring the user to write code using general purpose statements; and (b) provided as a system service. using the operating system software including a programming language and monitoring facilities (which may reference state variables) to provide the necessary support for the functionality, together with the debugging support provided. 95, the claim further comprising the step of recording in the system software for later use information consisting of the transitions that occur and the order in which these transitions occur as to which states are active in the system. The method according to scope item 94. 96. The method of claim 95, further comprising the steps of retrieving the information and providing it to a user. 97. Claims further comprising the step of recording in the system software information indicating which logical evaluation or evaluations caused the corresponding state transition or transitions during program processing. The method according to paragraph 95 or paragraph 96. 98, providing one or more program loops, each program loop corresponding to a state diagram, at least one of the program loops being active, which program loops are being executed and the corresponding transition state; 98. The method of any of claims 95-97, further comprising the step of recording information in the system software indicating whether the occurrence was so triggered. 99, further comprising providing each program loop with a program state corresponding to a state of a state diagram, and providing that only one of the program states is active in each of the active program loops at a time point; A method according to claim 98. 100. The method of claim 99, further comprising the steps of providing each program loop with an identifier and recording in the information a program loop identifier for the loop in which the logical evaluation occurred. 101. The method of claim 100, further comprising the step of recording in the information the location in the program at which the conditional portion of the state activity change compound statement was determined to be true. 102, when the recorded information includes the memory locations in the program at which the determination was made that the conditional portion of a state activity change compound statement was true, such information providing syntax rules to the program for statements so as to specify the information necessary to uniquely determine which terms of a portion cause which state-activity transitions when read in the context of the program; 102. The method of claim 101 further constructed by. 103. The method of any one of claims 95 to 102, further comprising recording in the information a time at which a state activity transition occurred. 104. configuring said controller to place a state in a break state, which, when activated, causes a predetermined debug function to be generated, the debug function being configured to control a monitor program of an operating system; Claim 9 further comprising the step of stopping the application program so that it can be returned to parts for debugging and review purposes.
104. A method according to the programmable control device according to any one of clauses 8 to 103. 105. configuring the controller to put a state into a pause state, the pause state, when activated, generating a predetermined debug function, the debug function stopping during processing of a program loop; 105. A method as claimed in any one of claims 94 to 104, further comprising the step of causing a condition during this suspension but not affecting the processing of other program loops. 106. configuring the controller to place a state in a stopped state, the stopped state causing a predetermined debug function to occur when the state is activated, the debug function indicated by a stop statement. Claim 1 further comprising the step of advancing a halt portion through the processing of a program state at a point, said halt statement being selectively conditional, but having no effect on the processing of other program loops. Paragraphs 94 to 105
The method described in any of the preceding sections. 107. Claim 94 provides for each state as a program state represented in the program by a state identifier associated with a block of statements, and defines the steps necessary to emulate the state on the state diagram. to paragraph 106. 108, a patent further comprising the step of providing a variable associated with each active program loop to store a value indicative of each active state block, said variable being assigned to indicate state activity. 108. The method of claim 107. 109. The method according to claim 107 or 108, further comprising the step of storing a value indicating an active state, said step comprising a pointer to a state block or an identifier for the state block. the method of. 110, further comprising the step of providing that other properties of a "break" or "pause" or other debug function are related to a state by being encoded in a statement that is also used as a bounding statement for the state. The method according to claim 108 or 109. 111. A method of controlling the operation of at least one device or process controlled by a programmable controller by emulating one or more state diagrams, the controller defining one or more state diagrams. (a) providing said application program as a block of at least a plurality of statements, each said block being a program state corresponding to a state of a state diagram; (b) providing the program with at least some of the blocks each comprising one or more statements defining at least one control action to be taken during scanning of the blocks; (c) at least one of said program loops is active, and only one of said program states is active at any one time. (d) processing program statements in each active program state of each active program loop, thereby controlling the operation and state sequence of the machine or process; A method of controlling the operation of a single device or process. 112. The need to evaluate whether a particular state is active in order to make a state-dependent decision or to perform a state-dependent activity that depends on the activity of the state of the program loop in which the state-dependent statement appears. Claim 11 further comprising the step of configuring the program to exclude
The method described in Section 1. 113, collecting all statements in a state block for a particular state that include state-dependent evaluations or actions that depend on that particular state; and executing only those statements that appear in state blocks of active states in the system; Accordingly, whenever a particular state is inactive, the recognition of a particular state as active and inactive, thus implying the inactivation of the action, and when the said statement is executed, the said active state 113. The method of claim 112, further comprising the step of eliminating the need to evaluate the state variable because active certification is implied by the method. 114, any of claims 111 through 113, further comprising the step of having a variable associated with each active program loop and storing a value indicating the beginning of an active program state in the loop. The programmable control device according to claim 1. 115. The programmable control device of claim 113, wherein said variable comprises a pointer holding a starting address of a state block. 116, using operating system software means, further taking the value of a variable indicating the beginning of a first program state block to be processed from the first initialized one of said variables, and processing the first state block; change the value stored in that variable or any other variable if a change is indicated by the processing of the first state block, maintain a requested record of the activity of the current state block, and so on. Claim 1 further comprising the step of using said operating system software to advance a program by processing the program iteratively processing each of the active blocks in a desired order.
The method according to item 15. 117, activate a specific program loop,
further comprising the step of providing each said pointer with an identifier that enables initialization of the particular pointer into a particular state block for subsequent processing in a known order with respect to other program loops and for use in debugging. A method according to claim 115 or 116. 118. The method of any of claims 111 through 117, further comprising the step of delimiting a state block using a state statement that relates a state identifier to the state block. 119. The method of claim 118, further comprising the step of organizing the pointers into a task table to facilitate control of the processing in the known order.