State machine functional block with user-definable actions at a transition between states, procedure for configuration, and material carrier.

Abstract

Method for configuring, via a computer device comprising a display device and an input device, a functional block linked to a process plant, wherein the functional block is designed to implement a state machine, the method comprising the following steps: - Providing a graphical user interface displayed by the display device, wherein the graphical user interface specifies a first plurality of cells associated with the function block and arranged in a matrix having a first dimension and a second dimension, wherein the positions along the first dimension specify states of a state machine and associated identifiers of transition actions, and positions along the second dimension correspond to the inputs of the state machine, such that the first plurality of cells define input / state pairs and their transition actions based on the positions of the first plurality of cells with respect to the first and second dimensions; - Receiving state transition data associated with a cell of the first plurality of cells via the input device, wherein the state transition data identify a next state to which the state machine transitions according to a condition in the process plant corresponding to the input / state pair defined by the cell; - Receiving transition action data via the input device, wherein the transition action data identifies at least one transition action to be executed according to the state transition data; and - Storing the state transition data and the transition action data on a computer-readable medium linked to the functional block, characterized in that the transition action data identify at least one of 1) a transition-off action to be executed when transitioning from the state of the state machine corresponding to the cell, and 2) a transition-in action to be executed when transitioning to the next state, wherein the method comprises the following steps: - Displaying the first multitude of cells on the display device; and - Displaying an indication of the next state, an indication of the transition-out action, and an indication of the transition-in action in the cell, where displaying the indication of the next state, the indication of the transition-out action, and the indication of the transition-in action in the cell comprises the following steps: - Displaying the indication of the next state in a first subcell of the cell; - Displaying the transition-off action in a second sub-cell of the cell; and - Displaying the transition-in action in a third subcell of the cell.

Description

AREA OF INVENTION

[0001] The present disclosure generally relates to functional blocks for use in process plants and, more specifically, to the configuration and implementation of a state machine belonging to a process plant. GENERAL STATE OF THE ART

[0002] Process control systems, such as those used in chemical, petroleum, or other processes, typically comprise one or more process controllers that are communicatively coupled to at least one host or operator workstation and to one or more field devices via analog, digital, or combined analog / digital buses or lines. The field devices, which may include valves, valve positioners, switches, and transmitters (e.g., temperature, pressure, and flow sensors), perform functions within the process plant, such as opening or closing valves and measuring process parameters.The process controllers receive signals indicating process measurements taken by the field devices and / or other information related to the field devices. They use this information to implement control routines and then generate control signals that are sent via buses or lines to the field devices to regulate the operation of the process. The information from the field devices and the controllers is typically made available to one or more applications run from the operator workstation, enabling the operator to perform any desired function related to the process, such as configuring the process, visualizing the current state of the process, changing the process's operation, and so on.

[0003] In addition, many processes employ a separate safety system to detect significant safety-related problems within the process plant and automatically close valves, cut off power to equipment, reverse flows within the plant, etc., if a problem occurs that could pose or cause a serious hazard in the plant, such as a spill of toxic chemicals, an explosion, etc. These safety systems typically have one or more separate controllers, in addition to the standard process control controllers, called logic solvers, which are connected to safety field devices via separate buses or communication lines installed within the process plant.The logic solvers use the safety field devices to identify process conditions associated with significant events, such as the position of certain safety switches or shut-off valves, overflows or underflows in the process, the operation of critical power generation or control equipment, the operation of fault detection devices, etc., in order to identify "events" within the process plant. When an event (typically referred to as a "cause") is identified, the safety controller takes certain actions (typically referred to as an "effect") to mitigate the harmful nature of the event, such as closing valves, shutting down equipment, cutting off power to parts of the plant, etc.In general, these measures or effects include switching safety devices into a triggered or “safe” operating mode designed to prevent a serious or hazardous condition within the process plant.

[0004] Systems within a process plant, such as process control systems and safety systems, can typically monitor the states of various processes and / or the systems themselves. Input signals to a system can cause the state being monitored to change, and output signals generated by the system can depend on the current state of the system in addition to the input signals to the system. U.S. Patent No. 7,730,415, hereby incorporated in its entirety for reference, describes a control system within a process plant that uses state machine function blocks integrated into a function block diagram programming environment. In particular, such a state machine function block comprises one or more inputs used to cause the state of a state machine implemented by the state machine function block to change.Furthermore, the state machine function block determines the next state to which it should transition, based on state transition configuration data that specifies the next state. This state transition configuration data is retrieved from a database based on the current state of the state machine and at least one of its inputs. The state machine function block also includes one or more outputs that are generated based on the state machine's state. The inputs to the state machine function block are, for example, connected to a process control system or a safety system, and the outputs can be used, for example, to control field devices within the process control system or the safety system.

[0005] Current process control systems are unable to automatically execute various actions or functions associated with transitions from one state to another. Instead, users and administrators of current process control systems must manually execute or implement these actions or functions during state transitions. Therefore, current process control systems are limited in their ability to implement certain safety measures, control techniques, and other features associated with state transitions.

[0006] A method with the features of the preamble of claim 1 is known from publication DE 10 2004 042 550 A1. SUMMARY

[0007] The present invention is defined as a method for configuring a functional block linked to a process plant, comprising the features of claim 1. Advantageous embodiments of the inventive concept are the subject of the dependent claims. A material carrier that has stored machine-readable instructions is also claimed, according to claim 11.

[0008] The systems and methods described here relate to the handling of transitions between the states of a process control environment. These systems and methods can implement a state machine that includes a transition table identifying transitions between various states of the state machine based on acknowledged inputs. The transition table can further specify one or more transition actions for the process control systems and methods to be executed in connection with the transition from a current state to the next state. According to the embodiments, the transition actions can be in the form of transition-in actions and / or transition-out actions. The process control systems and methods can execute the transition-out actions in connection with the transition from a current state and can execute the transition-in actions before stabilizing in the next state.In some embodiments, the process control systems and methods can provide configuration data associated with the transition actions to another function block for execution. The process control systems and methods can also set outputs corresponding to the current state and the transition actions.

[0009] As explained below, process control systems and procedures can handle the transition table via matrices, which can be displayed by a graphical user interface. Various cells of the matrices can specify state transition data, identifying various state transitions associated with acknowledged inputs, along with transition actions to be executed in connection with those state transitions. The matrices can be fully configurable by a computer or its user to specify state transitions and their associated transition actions. Therefore, a function block can access the appropriate matrices to enable state transitions, automatically execute the associated transition actions, and set appropriate outputs.

[0010] The process control systems and methods described here can lead to more effective and efficient process control techniques compared to conventional methods. For example, transition actions enable process control systems and methods to automatically execute actions associated with transitioning from a current state to a new state, thereby reducing the need for users to manually execute processes related to state transitions. BRIEF DESCRIPTION OF THE DRAWINGS

[0011] The features and advantages of the methods, devices, and systems described here will be best understood with reference to the following detailed description and the accompanying drawings. These show: Fig. 1 a block diagram of an exemplary process plant; Fig. 2. A block diagram of an example workstation located in Fig. 1 is shown schematically; Fig. 3 an example display representing a control module; Fig. 4 an example of a representation of a state machine function block; Fig. 5 an exemplary matrix for entering state configuration data and transition action data, which are linked to it for a state machine function block; Fig. 6 the exemplary matrix from Fig. 5, where state configuration data and associated transition action data are displayed in the matrix; Fig. 7. A flowchart of an exemplary procedure for the operation of a state machine function block with transition action function; Fig. 8 a block diagram of an exemplary state machine function block that integrates a transition action function; Fig. 9 a flowchart of another exemplary procedure of the operation of a state machine function block with transition action function; Fig. 10 a flowchart of an exemplary routine for processing data inputs into a state machine function block; Fig. 11 a flowchart of an exemplary routine for processing a release input for a state machine function block; Fig. 12 a flowchart of an exemplary routine for changing a state and setting outputs, including transition action outputs of a state machine function block; Fig. 13 an exemplary matrix for entering output configuration data, including transition actions for a state machine function block; Fig. 14 a block diagram of another exemplary state machine function block; and Fig. 15 An exemplary state transition diagram for entering state configuration data and associated transition action data for a state machine function block. DETAILED DESCRIPTION Exemplary process plant

[0012] Fig. Figure 1 is a block diagram of an exemplary process plant 10, which includes one or more nodes 12, 16, 18, and 20. In the exemplary process plant 10 from Fig. Each of nodes 12 and 16 comprises a process controller 12a, 16a, which is connected to one or more field devices 22 and 23 via input / output (I / O) devices 24, which can be, for example, Foundation Fieldbus interfaces, HART interfaces, etc. The controllers 12a and 16a are also coupled to one or more host or operator workstations 18a and 20a in nodes 18 and 20 via a network 30, which can include, for example, one or more buses, a wired local area network (LAN) such as an Ethernet LAN, a wireless LAN, a wide area network (WAN), an intranet, etc.While the controller nodes 12, 16 and the I / O devices 24 and the associated field devices 22, 23 are typically located and distributed within the sometimes harsh plant environment, the operator workstation nodes 18 and 20 are usually located in control rooms or other less harsh environments that are easily accessible to the controller personnel.

[0013] In general, workstations 18a and 20a of nodes 18 and 20 can be used to store and run applications used to configure and monitor process plant 10, and / or to manage devices 22, 23, 24 and controllers 12a, 16a in process plant 10. Furthermore, a database 32 can be connected to network 30 and function as a data archive and / or configuration database, storing the current configuration of process plant 10 as downloaded and / or saved within nodes 12, 16, 18, 20, 22, 23, 24, 50, and 70.

[0014] Each of the controllers 12a and 16a, which could be, for example, the Delta V™ controller marketed by Emerson Process Management, can store and execute a controller application that implements a control strategy using a certain number of different, independently executed control modules or blocks. The control modules can each consist of what are commonly referred to as function blocks, where each function block is a part or subroutine of a global control routine and operates in conjunction with other function blocks (via communication means called links) to implement process control loops within the process plant 10.As is well known, functional blocks typically perform an input function (such as one linked to a transmitter, sensor, or other process parameter measuring device), a control function (such as one linked to a control routine that performs various control operations, such as PID, fuzzy logic, etc.), or an output function that controls the operation of a device (such as a valve) to perform a certain physical function within the process plant 10. Of course, there are hybrid and other types of functional blocks that can be used.Although a fieldbus protocol and the DeltaV™ system protocol can use control modules and function blocks designed and implemented in an object-oriented programming protocol, the control modules could be designed using any desired control programming method, including, for example, sequential function blocks, ladder logic, etc., and are not restricted to being designed using function blocks or any other specific programming technique. Typically, the configuration of the control modules, as stored in the process control nodes 12 and 16, can be stored in the configuration database 32, which is accessible to applications running from the workstations 18a and 20a.The function blocks can, for example, be stored and executed in the controller 12a, 16a, as is typically the case when these function blocks are used for or linked to standard 4-20mA devices and certain types of intelligent field devices, such as HART devices, or they can be stored and implemented in the field devices themselves, as may be the case with fieldbus devices.

[0015] At the in Fig. In the system shown in Figure 1, the field devices 22 and 23, which are coupled to the controllers 12a and 16a, can be standard 4-20 mA devices, or they can be intelligent field devices, such as HART, Profibus, or Foundation Fieldbus field devices, which include a processor and memory. Some of these devices, such as Foundation Fieldbus field devices (in Figure 1), Fig. Modules or sub-modules (designated with reference number 23, 1) can store and execute modules or sub-modules, such as function blocks, that are linked to the control strategy implemented in the controllers 12a and 16a. Of course, the field devices 22 and 23 can be any type of device, such as sensors, valves, transmitters, positioners, etc., and the I / O devices 24 can be any type of I / O device that adapts to a desired communication or control protocol, such as HART, Foundation Fieldbus, Profibus, etc.

[0016] Controllers 12a and 16a each comprise a processor that executes or oversees one or more process control routines stored in memory. These routines may include control loops stored in memory or otherwise linked to it. Controllers 12a and 16a communicate with field devices 22 and 23, workstations 18a and 20a, and database 32 to control a process in a desired manner. Controllers 12a and 16a can each be configured to execute a control strategy or control routine in any desired way. It is understood that controllers 12a and 16a can communicate wirelessly with field devices 22 and 23, workstations 18a and 20a, and database 32.

[0017] The process plant 10 may also include a safety system 14 (indicated by dotted lines) that is integrated with the process control nodes 12 and 16. The safety system 14 can generally function as a safety engineering system (SIS) to monitor or override the control provided by the process control nodes 12 and 16 in order to maximize the likely safe operation of the process plant 10.

[0018] Each of the nodes 12 and 16 can include one or more Logic Solvers 50 of the safety system. Each Logic Solver 50 is an I / O device that has a processor and memory and is configured to execute logical safety modules stored in the memory. Each Logic Solver 50 is communicatively coupled to provide control signals to the field devices 60 and 62 of the safety system and / or to receive signals from them. In addition, each of the nodes 12 and 16 includes at least one message distribution device (MPD) 70, which is connected via a ring or bus connection 74 (from which in Fig. (1 only a part is shown) is communicatively connected to other MPD 70s. The Logic Solver 50 of the safety system, the field devices 60 and 62 of the safety system, the MPD 70 and the bus 74 generally form the safety system 14. Fig. 1.

[0019] The Logic Solver 50 from Fig. 1 can be any desired type of safety system control device, including a processor and memory that stores logical safety modules suitable for execution on the processor to provide control functionality linked to the safety system 14 using the field devices 60 and 62. Of course, the safety field devices 60 and 62 can be any desired type of field device that conforms to or uses any known or desired communication protocol, such as those mentioned previously. In particular, the field devices 60 and 62 can be safety-related field devices of the type conventionally controlled by a separate, dedicated safety control system. In the process plant 10, which is located in Fig. Figure 1 shows the safety field devices 60 using a dedicated or point-to-point communication protocol, such as the HART or 4-20mA protocol, while the safety field devices 62 show using a bus communication protocol, such as a fieldbus protocol.

[0020] The safety field devices 60 can perform any desired function, such as that of a shut-off valve, a cut-off switch, etc.

[0021] A common backplane (not shown) can be used in each of nodes 12 and 16 to connect controllers 12a and 16a to the process control I / O cards 24, the safety logic solvers 50, and the MPD 70. Controllers 12a and 16a are also connected to network 30. Controllers 12a and 16a, I / O devices 24, logic solvers 50, and the MPD 70 can communicate with nodes 18 and 20 via network 30.

[0022] As a person skilled in the art will understand, the (not shown) backplane in nodes 12 and 16 enables the Logic Solver 50 to communicate locally with each other to coordinate the safety functions implemented by these devices, to transmit data to each other, and / or to perform other integrated functions. Similarly, the (not shown) backplane in node 16 enables the Logic Solver 50 to communicate locally with each other to coordinate the safety functions implemented by these devices, to transmit data to each other, and / or to perform other integrated functions. Furthermore, the MPD 70 enables parts of the safety system 14, located in completely different positions within plant 10, to continue communicating with each other, thus providing coordinated safety operation across different nodes of process plant 10.In particular, the MPD 70, together with the bus 74, enables the logic solvers 50, which are linked to various nodes 12 and 16 of the process plant 10, to be cascaded together for communication purposes, thus allowing the cascading of safety-related functions within the process plant 10 according to an assigned priority. The MPD 70 and the bus 74 provide the safety system with a communication link that is an alternative to the network 30.

[0023] Alternatively, two or more safety-related functions at different locations within the process plant 10 can be interconnected or linked without requiring a dedicated line to individual safety field devices in the separate areas or nodes of the plant 10. In other words, the use of the MPD 70 and 72 and the bus 74 enables a safety engineer to design and configure a safety system 14 that is distributed throughout the entire process plant 10, but whose various components are interconnected for communication purposes, allowing the dissimilar safety-related hardware to communicate with each other as needed.This feature also provides scalability for the safety system 14 by offering the possibility to add additional safety logic solvers to the safety system 14 as needed, or when new process control nodes are added to the process plant 10.

[0024] Fig. Figure 2 is a block diagram of an exemplary workstation 18a (workstation 20a may comprise the same or a similar device). Workstation 18a may comprise at least one processor 100, one volatile memory 104, and one non-volatile memory 108. The volatile memory 104 may, for example, comprise a working memory (RAM). In some embodiments, the RAM may be protected by one or more batteries so that the data is not lost in the event of a power failure. The non-volatile memory 108 may, for example, comprise one or more of a hard disk, a ROM, a CD-ROM, a programmable ROM (PROM), an erasable programmable ROM (EPROM), an electrically erasable programmable ROM (EEPROM), a DVD (“Digital Versatile Disk”), flash memory, etc. Workstation 18a may also include a workstation I / O device 112.The processor 100, the volatile memory 104, the non-volatile memory 108, and the workstation I / O device 112 can be interconnected via an address / data bus 116. The workstation 18a can also include at least one display device 120 and at least one user input device 124, which may be, for example, one or more keyboards, keypads, mice, ballpoint pens, touchscreens, light pens, etc. In some embodiments, one or more of the volatile memory 104, the non-volatile memory 108, and the workstation I / O device 112 can be coupled to the processor 100 via a bus separate from the address / data bus 116 (not shown), or can be coupled directly to the processor 100.

[0025] The display device 120 and the user input device 124 are connected to the workstation I / O device 112. Additionally, the workstation 18a is connected to the network 30 via the workstation I / O device 112. Although the workstation I / O device 112 is in Fig. Although Figure 2 is depicted as a single device, it may comprise multiple devices. Additionally, in some embodiments, one or more of the display device 120 and the user input device 124 may be directly coupled to the address / data bus 116 or the processor 100.

[0026] Now, with reference to Fig. 1 and Fig. 2. An application for configuring the process control, coupled to one or more of the control nodes 12, 16, can be stored on and executed by one or more of the workstations 18a and 20a. For example, the application for configuring the process control could be stored in non-volatile memory 108 and / or volatile memory 104 and executed by processor 100. However, if desired, this application could be stored and executed on other computers linked to the process plant 10. In general, the application for configuring the process control allows a programmer to create and configure control routines, control modules, function blocks, programs, logic, etc., to be implemented by the controllers 12a, 16a, the I / O devices 24, and / or the field devices 22, 23. These control routines, control modules, function blocks, programs, logic, etc.can then be downloaded into a corresponding copy from the controllers 12a, 16a, the I / O devices 24 and / or the field devices 22, 23 via the network 30.

[0027] Similarly, an application for configuring the safety system, linked to safety system 14, can be stored and executed on one or more of the workstations 18a and 20a. For example, the application for configuring the safety system could be stored in non-volatile memory 108 and / or volatile memory 104 and executed by processor 100. However, if desired, this application could also be stored and executed on other computers linked to process plant 10. In general, the application for configuring the safety system allows a programmer to create and configure control routines, control modules, function blocks, programs, logic, etc., to be implemented by controllers 12a, 16a, logic solvers 50, and / or devices 60, 62. These control routines, control modules, function blocks, programs, logic, etc.can then be downloaded to suitable copies of the controllers 12a, 16a, the Logic Solvers 50 and / or the devices 60, 62 via the network 30. State machine function block

[0028] An application for configuring a control system or safety system can enable the programming of control modules and / or control routines using a function block programming paradigm. Fig. Figure 3 shows an example of a display 150, which represents a control module 154. The display 150 can be part of a user interface linked to the configuration application, and the display 150 can be presented to a programmer, for example, via the display device 120 of the workstation 18a. The display 150 represents the control module 154, which has a set of communicatively interconnected function blocks that can be created on corresponding instances of the controllers 12a, 16a, the I / O devices 24, the logic solvers 50, and / or the devices 22, 23, 60, 62, and downloaded to them via the network 30 for implementation during the operation of a process plant. As shown in Fig. As shown in Figure 3, the control module 154 comprises a state machine function block (SMFB) 160, a variety of analog input (AI) and digital input (DI) function blocks, a variety of analog output (AO) and digital output (DO) function blocks, and other function blocks (FB). The SMFB 160 has inputs that are interconnected for communication purposes with the function blocks 114, which can be, for example, DI function blocks or other FBs. The SMFB 160 also has outputs that are connected to the function blocks 118, which can be, for example, DO function blocks or other FBs. The control module 154 can be one of a variety of control modules that together control devices, such as switches, valves, etc., as part of a control system, a safety system, etc. Of course, the control module 154 is only one example of a control module that uses SMFB.In general, a control module can be programmed in any desired way to include any type of function block, which can be communicatively coupled to any number of SMFBs in any way, and configured in any desired or useful way to perform any desired function. For example, if used in a fieldbus network, a control module can include any type of fieldbus function block.

[0029] In some embodiments, one or more of the inputs for the SMFB 160 can be received by means other than a function block. For example, several of the inputs to the SMFB 160 can be communicatively coupled to receive inputs from an operator, for instance, via an operator interface. For example, an operator could provide inputs to the SMFB 160 using an operator interface implemented at a node, such as node 18 or 20.

[0030] The SMFB can be a functional block that implements a state machine. In some embodiments, a state machine can comprise an entity (e.g., a device, software executed by a processor, etc.) that can be in one of a multitude of states. The state machine can transition from one state to another if a specific input is provided to the state machine. The SMFB can provide outputs based on the current state of the state machine. As just one example, the SMFB can provide one or more outputs that indicate the current state of the state machine. More generally, a state machine can comprise an entity (e.g., a device, software executed by a processor, etc.) that represents a state of the entity or of some other entity (e.g., a process plant, a sub-unit of a process plant, a component of a process plant, etc.).) stores at a specific time and can change the state and / or cause an action or output to occur based on the inputs to the state machine.

[0031] Using the user interface associated with the configuration application, the programmer can design a rule module, such as rule module 154. As just one example, the user interface can provide a mechanism for the programmer to select desired function blocks from, for instance, a template or palette containing a variety of standard or custom function block templates. Additionally, the user interface can provide a graphical diagram onto which the programmer can insert or place representations of function blocks. The programmer can, for example, use a mouse, D-pad, keyboard, keypad, touchscreen, etc., to select a function block from the template or palette and then "drag and drop" the function block onto the graphical diagram.The programmer can additionally link function blocks for communication purposes by, for example, drawing a line between an output of one function block and an input of another function block using a mouse, a control ball, a keyboard, a keypad, a touchscreen, etc.

[0032] Once configured, the control module 154 can be implemented, for example, by one or more of the controllers 12a, 14a, 16a, the I / O devices 24, the Logic Solver 50 and the devices 22, 23, 60, 62.

[0033] Fig. Figure 4 is an example of a representation of an SMFB 200, which might be connected to a user interface display, such as the display 150 from Fig. 3, can be displayed. The diagram of the SMFB 200 indicates that the SMFB 200 comprises seven data inputs (IN_D1 to IN_D7) and seven data outputs (TRANS_OUT, TRANS_IN, STATE, and OUT_D1 to OUT_D6). The data inputs can generally specify conditions within the process plant, operator commands, etc., and can cause the states of a state machine implemented by the SMFB 200 to change. The data outputs can include one or more indicators of the state of the state machine corresponding to the SMFB 200, as well as configuration elements corresponding to functions or actions to be executed based on the state. For example, the STATE output can be an indicator of the state (e.g., State 1, State 2, State 3, etc.) of the state machine. The OUT_D1 output can be an indicator of whether the state machine is in a "State 1" state. Similarly, the outputs OUT_D2, OUT_D3, ...OUT_D6 can be indicators of whether the state machine is in each of the states "State 2", "State 3" ... "State 6". Additionally, the output TRANS_OUT can specify a configuration element to be executed when the state machine transitions from a particular state, and the output TRANS_IN can specify a configuration element to be executed when the state machine transitions into a particular state. In some embodiments, the SMFB 200 can include a plurality of TRANS_OUT outputs and a plurality of TRANS_IN outputs. For example, the SMFB 200 can include a number of TRANS_OUT outputs and a number of TRANS_IN outputs equal to the number of states (i.e., one TRANS_OUT output and one TRANS_IN output per state). It is understood that the SMFB 200 can include any number of TRANS_OUT and TRANS_IN outputs.

[0034] The SMFB 200 can also include inputs other than data inputs, such as an ENABLE input, a TRK_VAL input, and a TRK_IN_D input. For example, the SMFB 200 can have an input from another SMFB. Furthermore, the SMFB 200 can also include outputs other than those indicating the state or related configuration elements. The ENABLE, TRK_VAL, and TRK_IN_D inputs are described in more detail below. Although the SMFB 200 in Fig. As shown in Figure 4, the SMFB 200 has seven data inputs and nine data outputs. Other embodiments can include any desired number of data inputs and outputs. The number of data inputs and outputs of the SMFB 200 can be configurable or not. In one embodiment, the number of outputs OUT_Dx generally corresponds to the number of possible states of the state machine implemented by the SMFB 200, and the number of possible states can be configurable. However, the number of outputs OUT_D1, OUT_D2, etc., need not necessarily correspond to the number of possible states of the state machine. For example, if there are fewer states than the number of outputs OUT_D1, OUT_D2, etc., the remaining outputs can remain unused.

[0035] Using the user interface associated with the configuration program, the programmer can configure one or more function blocks, such as the SMFB 200. When configuring the SMFB, the programmer can specify a number of possible states, how the inputs cause the state machine to transition between states, and any functions or actions to be executed before, during, or after the state machine transitions between states. To allow a programmer to configure the SMFB 200, a configuration application on the display unit 120 can display a user interface mechanism, such as a configuration window, a screen, etc., that is associated with the function block.

[0036] Fig. 5 is an example of a user interface mechanism that can be used to implement an SMFB, such as the SMFB 200 from Fig. 4. To be configured, at least partially. The user interface mechanism includes a Table or Matrix 300 (hereafter referred to simply as "Matrix 300") that can be displayed as part of a configuration window, screen, etc., linked to the SMFB. Matrix 300 comprises a plurality of cells (302, 303, 304) arranged in rows and columns. As shown, the columns are arranged in groups of three, each group being able to correspond to one of a plurality of possible states of a state machine. In particular, the middle column within each group corresponds to a specific state of the state machine as contained in conventional state diagrams. For example, as in Fig. As shown in Figure 5, the state labeled "1" is the "TRIPPED" state, the state labeled "2" is the "WAIT TO RESET" state, and so on. According to the embodiments, the left column in each group corresponds to a configuration element that the state machine should execute when transitioning to the next state ("transition-in action"), and the right column in each group corresponds to a configuration element that the state machine should execute when transitioning from the current state ("transition-out action"). Furthermore, each row corresponds to an input to the state machine (e.g., "START", "RESET ALLOW", etc.).Accordingly, each of the cells 302 (which repeat for each row and column group) specifies a transition-in action, each of the cells 303 (which repeat for each row and column group) specifies an input / state pair, and each of the cells 304 (which repeat for each row and column group) specifies a transition-out action. It is understood that a group of cells 302, 303, 304 can be combined into a single cell. Furthermore, it is understood that each of the cells 302, 303, 304 can be a subcell of a cell corresponding to a specific state. Although the example matrix includes 300 rows for seven inputs and six state groups, similar matrices with different numbers of state groups and output groups can be used for SMFBs with different numbers of inputs and state groups. The number of inputs and state groups can be configured.In other examples, the rows can correspond to one of a multitude of possible states of the state machine (as well as the associated transition-in and transition-out actions), and each column can correspond to an input for the state machine.

[0037] During operation, the state machine can transition from its current state to the next state depending on an input that is acknowledged when the state machine is in its current state. For example, matrix 300 can specify that if the state machine is in the state "NORMAL OPERATION" (current state) and the input "TRIP REQUESTED" is acknowledged, the state machine should transition to the state "TRIPPED" (next state). In some cases, certain states may not specify a next state transition for a given input.

[0038] According to the embodiments, the transition-out action specified by the right-hand column in each group can correspond to one or more configuration elements that the SMFB executes according to the transition from a current state, and the transition-in action specified by the left-hand column in the group can correspond to one or more configuration elements that the SMFB executes according to the transition to a next state. In some embodiments, the one or more configuration elements can be logic in the form of structured text or a higher-level computer construct (e.g., C, C++, Java, etc.) that defines the actions to be executed. It is understood that the one or more configuration elements can be in the form of any type of code or executable logic.These can be a single, one-time action that the SMFB executes when transitioning from one state to the next. In some cases, this may cause one or more configuration elements to stop functioning or stop functioning once the next state is reached. The SMFB may first execute the transition-out action (i.e., leaving the current state causes the SMFB to execute the transition-out action) regardless of where the SMFB transition is going. Similarly, before stabilizing in the next state, the SMFB may execute the transition-in action (i.e., entering the next state causes the SMFB to execute the transition-in action), regardless of where the SMFB transition is coming from. In some cases, the configuration elements (i.e., the transition-in and transition-out actions) may affect other components or entities outside the SMFB (e.g., another function block).It goes without saying that other temporal components associated with the transition-in actions, the transition-out actions, and state changes are taken into consideration.

[0039] With reference to Fig. In this example, inputs "1" to "7" of matrix 300 correspond to inputs IN_D1 to IN_D7 of SMFB 200. Similarly, states "1" to "6" of matrix 300 correspond to outputs OUT_D1 to OUT_D6 of SMFB 200. Additionally, in this example, a programmer may be able to designate any possible state and / or any of the inputs. For example, in Fig. In step 5, “state 1” is labeled “Triggered”, and input 1 is labeled “Start”. Labeling the inputs and / or states can help to facilitate understanding how the state machine works.

[0040] A programmer can configure the SMFB 200 by entering configuration information into cells 302, 303, and 304. Specifically, for a given cell corresponding to an input / state pair, the programmer can enter configuration data specifying the state the SMFB 200 should transition to. Furthermore, for a given cell corresponding to a transition-in action, the programmer can enter configuration data specifying the action the SMFB 200 should perform when transitioning to the next state. Finally, for a given cell corresponding to a transition-out action, the programmer can enter configuration data specifying the action the SMFB 200 should perform when transitioning from its current state.

[0041] The SMFB 200 can acknowledge the TRANS_OUT output based on appropriate transition-out configuration data to execute a function after the state machine has transitioned from its current state. In some embodiments, the SMFB 200 can acknowledge the TRANS_OUT output before the state machine transitions from its current state. The SMFB 200 can acknowledge the TRANS_IN output based on appropriate transition-in configuration data after the state machine has transitioned from its current state (or otherwise before it transitions from its current state) and before the state machine stabilizes in the next state. In some embodiments, the SMFB 200 can acknowledge the TRANS_IN output after the state machine has stabilized in the next state.In some cases, the SMFB 200 can provide a configuration element corresponding to a transition-off or transition-in action as input to an additional SMFB or process controller to cause the additional SMFB or process controller to perform a function while the SMFB 200 either transitions from its current state or to the next state. Similarly, activating a TRANS_OUT output of a first SMFB can cause a second SMFB to transition to the next state.For example, in a process plant where the first SMFB controls a steam boiler, a TRANS_OUT output from the first SMFB indicating that it is transitioning from a switched-off state to a start-up state can cause a second SMFB, which controls a boiler venting fan, to transition from a switched-off fan state to a running fan state during a period before the first SMFB starts the boiler. Consequently, any build-up of explosive gases inside the boiler is vented before the boiler is heated.

[0042] Fig. Figure 6 is an example of Matrix 300 where configuration data is entered in some cells. For example, cell 303A contains configuration data specifying the next state the state machine should transition to when it is in the "TRIPPED" state and the "RESET ALLOW" input is confirmed. Specifically, the configuration data in cell 303A specifies that the state machine should transition to the "READY TO RESET" state. Furthermore, cell 302A contains configuration data corresponding to "ACTION A" that the SMFB should execute when it transitions to the "READY TO RESET" state, and cell 304A contains configuration data corresponding to "ACTION B" that the SMFB should execute when it transitions from the "TRIPPED" state.Similarly, cell 303B contains configuration data specifying that the state machine should transition to the "WAIT FOR START" state (from "READY TO RESET") when the "RESET" input is acknowledged; cell 302B contains configuration data corresponding to "ACTION C," which the state machine should execute when transitioning to the "WAIT FOR START" state; and cell 304B contains configuration data corresponding to "ACTION D," which the state machine should execute when transitioning from the "READY TO RESET" state. It is understood that ACTION A, ACTION B, ACTION C, ACTION D, etc., can correspond to any function or action executable by the SMFB or other components, as discussed herein.

[0043] Additionally, a specific cell or group of cells can contain a transition-in action without a transition-out action, or vice versa. For example, cell 303C contains configuration data specifying that the state machine should transition to the "TRIPPED" state (from "WAIT FOR START") when the "TRIPPED REQUESTED" input is acknowledged, and cell 302C contains configuration data corresponding to "ACTION E," which the state machine should execute when it transitions to the "TRIPPED" state. However, cell 303C does not have a corresponding TRANS_OUT configuration element. Therefore, if the state machine is in the "WAIT FOR START" state and the "TRIPPED REQUESTED" input is acknowledged, the SMFB can execute "ACTION E" according to the transition from "WAIT FOR START" to "TRIPPED."Similarly, an input / state pair (such as the one in cell 303D) may not have a corresponding configuration element TRANS_IN or TRANS_OUT. Accordingly, the state machine can transition from one state to the next without executing a configuration element of either TRANS_IN or TRANS_OUT.

[0044] In some embodiments, if the programmer does not enter any configuration data into a cell, it can be assumed that no state transition should occur for that particular state and input. For example, cells 302E, 303E, and 304E do not contain any configuration data specifying that if the state machine is in the "TRIPPED" state and the "START RECOVER" input is acknowledged, the state machine should remain in the "TRIPPED" state and not perform any actions. In other embodiments, the programmer can enter configuration data specifying that the state machine should not change its states for that particular state / input combination.

[0045] The programmer can enter configuration data into Matrix 300 using any of several techniques, including those well-known to professionals. For example, to enter configuration data into a cell, the programmer can select the cell using a mouse, a D-pad, a touchscreen, etc. The user could then enter configuration data directly into the cell using a keyboard or other input device. Alternatively, the programmer could select the cell and then make an "Edit," "Change," etc., selection from an action menu or select an "Edit," "Change," etc., button. The user interface can then present the programmer with a list of states via an action menu, window, screen, etc. Optionally, the state list can include the state corresponding to the cell or a "NO TRANSITION" selection.The programmer can then select one of the states using, for example, a keyboard, mouse, D-pad, touchscreen, etc. If the programmer selects the state corresponding to the cell or the "NO TRANSITION" selection, the configuration data would indicate that no transition should occur for this combination of state and input.

[0046] Configuring the SMFB using a user interface that includes a matrix, such as the Matrix 300, can simplify the implementation of a state machine compared to, for example, a sequential function diagram or a programming language like C++. For instance, implementing a state machine using a program in C++ would likely require first creating a state transition diagram with associated transition actions and then writing a program to implement the diagram. The program would then need to be tested and checked for errors, sometimes before being implemented in a process control system. However, with an SMFB configured using a matrix like the Matrix 300, it is not necessary to write a program. Instead, the "programming" would simply involve populating the matrix with the states and their associated transition actions.Because no additional software code needs to be written, debugging and testing of the code are unnecessary. Instead, testing can simply involve testing various combinations of states, transition-in actions, transition-out actions, and inputs to verify that the SMFB transitions to the correct next states and executes the desired transition actions. In some cases, the functionality of the SMFB is easy to understand by simply checking matrix 300. Thus, the functionality of a configured SMFB could easily be documented, for example, by printing a representation of the matrix.

[0047] A SMFB configured according to a matrix, such as Matrix 300, can be used, for example, in a safety system or a process control system. As just one example, an SMFB configured according to a matrix, such as Matrix 300, can be used as part of a safety system to manage a burner in a process plant. For example, the SMFB could include states such as "HEAT UP," "GAS SHUT DOWN," and "VENT." When the burner is started up, the SMFB could first enter the VENT state to vent any gas remaining in the burner. Then, the SMFB could enter the HEAT UP state to ignite the burner. Similarly, if the burner flame goes out, the SMFB could enter the GAS SHUT DOWN state to shut off the gas supply to the burner. Then, the SMFB could enter the VENT state.

[0048] Additionally, the SMFB can include transition-in and transition-out actions to enable the safety system. For example, the SMFB can include a transition-in action linked to the transition to the VENT state, which activates an operator indicator to inform the operator that the burner is being vented. Similarly, the SMFB can include a transition-out action linked to the transition from the VENT state, which informs the operator that the burner is being vented accordingly. Alternatively, the TRANS_OUT or TRANS_IN output of a first SMFB (e.g., a boiler control SMFB) can be used as an input for another SMFB (e.g., a boiler control SMFB).(an SMFB for controlling a boiler ventilation system) or another process control device is provided to cause the other SMFB or process control device to perform a function while the first SMFB transitions from the current state and / or to the next state.

[0049] An SMFB configured according to a matrix, such as matrix 300, can be implemented by one or more of the controllers 12a, 16a, the I / O devices 24, the logic solver 50, and the devices 22, 23, 60, 62. In some embodiments, the SMFB can be implemented by a processor configured according to software, by a programmable logic device, e.g., a device comprising one or more gate arrays, standard cells, user-programmable gate arrays (FPGAs), PROMs, EPROMs, EEPROMs, programmable array logic (PALs), programmable logic arrays (PLAs), etc.

[0050] The configuration data associated with an SMFB (for example, data entered into a matrix, such as Matrix 300, and optionally other configuration data) can be stored on a computer-readable medium, such as a hard disk, RAM, ROM, CD-ROM, EPROM, EEPROM, DVD, FLASH memory, etc., and / or memory associated with a processor.

[0051] Fig. Figure 7 is a flowchart of an example procedure 350 illustrating the operation of a configured SMFB. Procedure 350 can be executed regularly and / or, for example, in response to a trigger event. In block 354, the SMFB receives its data input(s). With reference to Fig. For example, in block 4, the SMFB receives one of the inputs IN_D1 through IN_D7. In block 356, the SMFB executes an appropriate transition-out action based on the current state and / or the data input(s). Specifically, the SMFB can execute the transition-out action using the associated transition-out configuration data stored in a configuration database. In block 357, the SMFB executes an appropriate transition-in action based on the next state (as specified by the current state and the data input(s)). Specifically, the SMFB can execute the transition-in action using the associated transition-in configuration data stored in a configuration database.

[0052] In Block 358, the SMFB may change the state of its state machine based on the data input(s), the current state of the SMFB, and the configuration data stored in a configuration database. For example, the SMFB might set the current state as the next determined state. The configuration database data may include data entered via a matrix, such as Matrix 300. The state may also be changed based on other factors. For instance, as described in more detail below, the SMFB may be configured to ignore one or more of the data inputs. Thus, the state change may also be based on configuration data specifying which data input(s) to ignore.As another example, two or more data inputs can specify that a state change should occur from the current state to two or more subsequent states. Thus, the SMFB can select one of the data inputs to determine which of the possible subsequent states the SMFB should transition to, based on priority data that prioritizes the data inputs. As yet another example, the data input(s) for the SMFB can include a status (e.g., a TRUE status or a FALSE status). Therefore, changing the state can also be based on configuration data that specifies how an input with a FALSE status should be handled.

[0053] Then, in block 366, the SMFB can set its data outputs based on the current state of the state machine. For example, the SMFB can set the STATE output (as well as a suitable OUT_Dx output) to the current state of the state machine. Furthermore, the SMFB can set the TRANS_OUT output to specify a transition-out action to be executed when the state machine transitions from the current state, and it can set the TRANS_IN output to specify a transition-in action to be executed when the state machine transitions to the next state.

[0054] Once again with reference to Fig. 4. The SMFB can optionally include an "ENABLE" input. If, in one embodiment, the ENABLE input is no longer acknowledged, the SMFB can be forced into a locked state (e.g., state 0) and must remain in this state until the ENABLE input is acknowledged. When the ENABLE input is acknowledged, the SMFB can be forced into an initial state (e.g., state 1), after which the SMFB, according to the configuration data stored in a configuration matrix, such as matrix 300, is configured. Fig. 5, which were entered, can transition into other states.

[0055] The SMFB can additionally include one or more inputs to force the state machine into a desired state. For example, SMFB 200 includes an input TRK_IN_D and an input TRK_VAL. If the input TRK_IN_D is acknowledged, the SMFB can be forced into a state specified by the input TRK_VAL. For example, if the input TRK_VAL is equal to "6" and the input TRK_IN_D is acknowledged, the SMFB can be forced into the state "6".

[0056] Optionally, there are additional ways to configure the SMFB. For example, the SMFB can include an input (or transition) mask that specifies whether one or more of the inputs IN_D1, IN_D2, etc., should be ignored. The SMFB can also be configured to respond to inputs that can have a variety of states. For example, one or all of the inputs can have a "true" or "false" state for the SMFB, and the SMFB can be configured to respond differently depending on the state of an input. In a specific example, the SMFB can be configured to ignore an input that is "false," to use the input even if it is "false," or to use the last "good" value of the input. Furthermore, the SMFB can include a RESET parameter which, if true, forces the SMFB into the "1" state.

[0057] The various configuration data described above and the configuration data of the next state can be stored on the same computer-readable medium or on different computer-readable media.

[0058] Fig. Figure 8 is a block diagram of an example SMFB 400. The SMFB 400 includes a logic 404 that determines a next state, based at least partially on the inputs IN_D1, IN_D2, etc., and the current state of the SMFB 400. Specifically, the logic 404 accesses the next state configuration data stored in a database 406. The logic 404 also determines the transition-in and transition-out actions to be performed by the SMFB 400. The transition-in action can be based at least partially on the transition-in configuration data from a database 405. The transition-out action can be based at least partially on transition-out configuration data from a database 407.According to the embodiments discussed here, the transition-in configuration data can define functions that the SMFB executes before stabilizing in a next state, and the transition-out configuration data can define functions that the SMFB executes before transitioning from a current state (or otherwise before transitioning to a next state). Databases 405, 406, and 407 can be stored on a computer-readable medium, as described here. The next-state, transition-in, and transition-out configuration data can include configuration data stored in a matrix, such as matrix 300. Fig. 5. It is understood that various components, logic elements, or modules can execute the data to configure the transition-in and / or transition-out. For example, the SMFB 400 can execute the data to configure the transition-in and / or transition-out. As another example, the SMFB 400 can send commands to a separate component or module to execute the data to configure the transition-in and / or transition-out.

[0059] In some embodiments, the output of logic 404 is provided to switching logic 408. Switching logic 408 selects between the output of logic 404 and the input TRK_VAL based on the input TRK_IN_D. For example, if the input TRK_IN_D is acknowledged, switching logic 408 can select the input TRK_VAL. Otherwise, switching logic 408 can select the output of logic 404.

[0060] The output of switching logic 408 is provided to switching logic 412, which selects between the output of switching logic 408, the value 0, and the value 1 based on the output of enable / reset logic 416. The output of enable / reset logic 416 indicates whether the state is to be forced into a locked state (state 0) or an initial state (state 1). Enable / reset logic 416 generates this output based on the ENABLE input. For example, if the ENABLE input is unacknowledged, the output of enable / reset logic 416 can indicate that the state is to be forced to 0. If the ENABLE input changes from unacknowledged to acknowledged, the output of enable / reset logic 416 can indicate that the state is to be forced to 1. If ENABLE is confirmed and was previously confirmed, the output of the enable and reset logic 416 can indicate that the state should not be forced to 0 or 1.

[0061] The output of switching logic 412 is the current state of SMFB 400 and can be provided as output of SMFB 400. The output of switching logic 412 can also be provided to logic 420, which sets a corresponding output OUT_D1, OUT_D2, TRANS_IN, TRANS_OUT, etc., that corresponds to the current state of SMFB. As in Fig. As shown in Figure 8, the logic 420 can optionally access state / output configuration data stored in an optional output configuration database 458. Database 458 and database 406 can be stored on the same computer-readable medium or on different computer-readable media. The output configuration data can include configuration data stored in a matrix, such as matrix 700. Fig. 13 are registered, as discussed here.

[0062] Each of blocks 404, 408, 412, 416, and 420 can be implemented by one or more hardware, software, and firmware components. Additionally, some of the blocks can be combined, rearranged, modified, or omitted, and extra blocks can be added. For example, blocks 408 and 412 could be combined into a single block.

[0063] Fig. Figure 9 is a flowchart of procedure 450 illustrating the functionality of the exemplary SMFB 400. Procedure 450 from Fig. Block 9 can be implemented regularly and / or upon a trigger event. Block 454 processes the data inputs of SMFB 400. For example, it can determine whether some of the data inputs IN_D1, IN_D2, etc., have been acknowledged. If one or more of the data inputs have a status of "FALSE," it can, as another example, determine how to handle one or more "FALSE" inputs. Block 458 processes the ENABLE input of SMFB 400. For example, it can determine whether the ENABLE input is acknowledged and / or whether it has changed since it was previously processed.

[0064] In a Block 459, the SMFB executes an appropriate transition-off action based on the current state and / or data inputs, for example, by accessing the linked data for configuring the transition-off, which is stored in a configuration database. In a Block 460, the SMFB executes an appropriate transition-in action based on the next state and / or data inputs, for example, by accessing the linked data for configuring the transition-in, which is stored in a configuration database. For example, the SMFB might be configured to control a facility within a process plant. If the facility is in a shut-off state (i.e., the current state), the data for configuring the next state can be executed when a facility start input is enabled and the facility transitions to an operating state (i.e., the next state).Before actually transitioning from the off state, the SMFB can execute the data to configure the transition-off, triggering an alarm indicating that the facility is about to start. Additionally, before stabilizing in the operating state, the SMFB can execute the data to configure the transition-in, silencing the alarm.

[0065] As another example, the SMFB can be configured to control multiple heating devices in a warehouse. When the process equipment is in a heating state (i.e., the current state), an input can be confirmed to start a fan, which is equivalent to transitioning to a ventilation state. During the transition from the heating state, the SMFB can automatically lock out a furnace or other heat source to prevent it from generating further heat. Similarly, the furnace will be prevented from operating after the transition to the ventilation state. Furthermore, prior to the transition to the ventilation state, the SMFB can automatically activate a set of ventilation holes linked to the fan to help ventilate the relevant machine.

[0066] In block 462, the state of SMFB 400 can be changed as needed. Additionally, one or more data outputs of SMFB 400 can be modified or configured as required. For example, it can be specified that a change in the data inputs indicates that the state of SMFB 400 needs to be changed. If the state also changes, one or more data outputs, such as TRANS_IN and TRANS_OUT, of SMFB 400 may need to be modified.

[0067] Several exemplary routines that can be used to implement procedure 450, at least partially, are now described. For example, Fig. Figure 10 shows a flowchart of an example routine 500 that can be used to process data inputs IN_D1, IN_D2, etc., in the SMFB. In block 504, a variable z is set to one. In block 508, it is determined whether the status of the data input IN_Dz is "FALSE". If the status is not false, then bit z of a variable TRANSITIONS is set to the value of the data input IN_Dz. If the status is false, it can then be determined how to handle the data input. In one example, the SMFB can handle the "FALSE" inputs in three ways: the input FALSE can still be used (ALWAYS_USE), it can be ignored (IGNORATE_IF_FALSE), or the last input value "TRUE" can be used (USE_LAST_TRUE). Thus, in block 516 it can be determined whether the SMFB should use the last data input as "correct".If the SMFB is to use the last value "TRUE", then block 512 can be skipped. Otherwise, block 520 determines whether the SMFB should ignore the input value FALSE. If the SMFB should not ignore the value FALSE, the routine can then continue with block 512. If the SMFB should ignore the value FALSE, the routine can then continue with block 524. In block 524, bit number "z" of the variable TRANSITIONS is set to 0.

[0068] In block 528, the variable z is incremented, and in block 532, it can be determined whether the variable z is greater than the number of data entries in the SMFB. If z is not greater than the number of data entries in the SMFB, the routine can return to block 508 to process the next data entry. Otherwise, the routine can terminate.

[0069] Fig. Figure 11 is a flowchart of an example routine 545, which can be used to process the ENABLE input for the SMFB. In block 550, it can be determined whether the value of a variable LASTENABLE is the same as the input ENABLE. The variable LASTENABLE generally indicates the value of ENABLE at a previous point in time (for example, the value of the variable ENABLE during the previous execution of routine 545). If the values ​​of LASTENABLE and ENABLE are the same, routine 545 can terminate. Otherwise, the routine can proceed to block 554, which determines whether the input ENABLE is acknowledged. If the input ENABLE is acknowledged, a variable RESET can be set to TRUE in block 558.

[0070] If block 554 determines that the input ENABLE is not acknowledged, then block 562 removes the acknowledgment of the output OUT_D1, OUT_D2, etc., which corresponds to the current value of a variable STATE. In block 566, the variable STATE is then set to 0. After blocks 558 and 566, the routine can continue with block 570, in which the variable LASTENABLE is set to the value of the input ENABLE. After block 570, the routine can terminate.

[0071] Fig. Section 12 is a flowchart of an example routine 600, which can be used to determine the next state of the SMFB and, if necessary, to set a suitable output such as OUT_D1, OUT_D2, TRANS_IN, TRANS_OUT, etc. Block 604 determines whether the input ENABLE is acknowledged. If not, the routine can terminate. If the input ENABLE is acknowledged, the routine can proceed to block 608, in which the variable NEWSTATE is set to 0. Then, in block 612, it can be determined whether the input TRK_IN_D is acknowledged. If it is acknowledged, the routine can proceed to block 616, in which the variable NEWSTATE is set to the value of the input TRK_VAL.

[0072] If block 612 determines that the input TRK_IN_D is not acknowledged, the routine can proceed to block 620. Block 620 determines whether the variable RESET is TRUE. If so, the routine can proceed to block 624, where the variable NEWSTATE can be set to 1. Finally, in block 626, the variable RESET can be set to FALSE.

[0073] If block 620 determines that the variable RESET is not TRUE, the routine can proceed to block 632. In block 632, a variable TEMP can be determined by adding, bit by bit, a variable TRANSITION_MASK, the variable TRANSITIONS, and an element of an array STATECHANGEMASK to which the variable STATE points, using an AND operation. The variable TRANSITION_MASK can be a configurable variable used to prevent certain inputs IN_Dx from causing a state change. For example, if a programmer wants to prevent the input IN_D3 from changing the state machine's state, they could set the third bit of the variable TRANSITION_MASK to 0. If the programmer wants to allow the input D3 to change the state machine's state, they could set the third bit of the variable TRANSITION_MASK to 1.

[0074] Each element of the array STATECHANGEMASK can be a variable that specifies, for a given state, which inputs IN_D1, IN_D2, etc., cause a state change. Specifically, each element of the array can correspond to one of the states of the state machine. For example, STATECHANGEMASK[1] can correspond to state 1, STATECHANGEMASK[2] can correspond to state 2, and so on. Additionally, each bit of each element can correspond to one of the inputs IN_D1, IN_D2, etc. For example, bit 1 can correspond to IN_D1, bit 2 can correspond to IN_D2, and so on. For example, with reference to Fig. 6 would have the array STATECHANGEMASK for the matrix 300 6 elements and the element STATECHANGEMASK[3] would be 0×44.

[0075] After block 628, the routine can proceed to block 632, where it determines whether the variable TEMP is equal to 0. If it is not equal to 0, the routine can proceed to block 636, where a variable z can be set to the number of the first bit (i.e., starting from the least significant bit) in the variable TEMP that is not equal to zero. This sets the input priorities based on their order, such that IN_D1 is the highest priority, IN_D2 is the next highest priority, IN_D3 is the next highest priority, and so on. In other implementations, different prioritization methods could be used. For example, a programmer could be allowed to assign priorities to the inputs, or a different priority order could be used (e.g., IN_D1 is the lowest priority, IN_D2 is the next lowest priority, and so on).Priorities can be set for the SMFB as a whole or for each individual state. Then, in block 640, the variable NEWSTATE can be set to the value of the state transition matrix in row z and column STATUS.

[0076] After blocks 616, 626, and 640, the routine can continue with block 644. If block 632 determines that the variable TEMP is equal to 0, the routine can also continue with block 644. Block 644 determines whether the variable NEWSTATE is equal to 0. If it is equal to 0, the routine can terminate. If it is not equal to 0, the routine can continue with block 645, in which the transition-out action can be executed. Then, in block 646, the transition-in action can be executed. In block 648, the acknowledgment of the outputs OUT_D1, OUT_D2, TRANS_IN, TRANS_OUT, etc., corresponding to the variable STATE, is deselected. It should be noted that the outputs whose acknowledgment is deselected do not necessarily have to correspond to the variable STATE. In block 652, the variable STATE is set to the value of the variable NEWSTATE. In block 656, the outputs OUT_D1, OUT_D2, TRANS_IN, TRANS_OUT, etc. are displayed.The routine acknowledges the outputs corresponding to the variable STATE, and then it can end. It should be understood that the outputs to be acknowledged do not necessarily have to correspond to the variable STATE.

[0077] It goes without saying that the procedure 450 from Fig. 9 and the routines from Fig. 10, Fig. 11 to Fig. The blocks shown are purely exemplary and can be modified, added, rearranged, omitted, and / or combined in other examples. With reference to Fig. For example, blocks 508, 516, 520 and 524 can be omitted if no special handling of the inputs with a status of "FALSE" is required or desired.

[0078] As another example, block 636 could be modified so that the variable z is set to the number of the last non-zero bit in TEMP. As yet another example, block 636 could be modified to set z to the number corresponding to one of the non-zero bits in TEMP, based on certain priority data.

[0079] Once again with reference to Fig. 4. Not all data outputs are necessarily indicators of the state of the state machine corresponding to the SMFB 200. For example, in one embodiment, the values ​​for the outputs OUT_D1, OUT_D2, etc., which correspond to the various states of the state machine, can be configured. Thus, for example, a variety of outputs OUT_D1, OUT_D2, etc., can be confirmed for certain states. To enable a programmer to configure the SMFB, a configuration application on the display device 120 can display a user interface mechanism, such as a configuration window, a screen, etc., which is linked to the function block.

[0080] Fig. 13 is an example of a user interface mechanism that can be used to configure at least part of an SMFB, such as the SMFB 200 from Fig. 4. The user interface mechanism includes a Table or Matrix 700 (hereinafter referred to as "Matrix 700") that can be displayed as part of a configuration window, screen, etc., linked to the SMFB. Matrix 700 comprises a plurality of Cells 704 arranged in rows and columns. Each column corresponds to one output from a plurality of outputs OUT_D1, OUT_D2, etc., TRANS_IN, and TRANS_OUT of the State Machine Function Block, and each row corresponds to one of the possible states of the State Machine. Thus, each Cell 704 corresponds to a state and an output. In other examples, each column can correspond to one of the plurality of outputs, and each column can correspond to one of the possible states of the State Machine.

[0081] Outputs "1" through "4" of Matrix 700 can each correspond to outputs OUT_D1 through OUT_D4 of the SMFB, and outputs "5" and "6" can each correspond to outputs TRANS_IN and TRANS_OUT. Similarly, states "1" through "6" of Matrix 700 can correspond to the possible states of the state machine. Additionally, in this example, a user can label each of the outputs. For example, in Fig. 13 “Output 1” is labelled “VLV-101 OPEN VALVE”. Labelling the outputs can help to facilitate understanding of the operation of the state machine and / or the creation of an interface between the state machine and the process plant.

[0082] A programmer can configure the SMFB by entering configuration information into cells 704. Specifically, for a given cell 704 corresponding to one of the states and one of the outputs, the programmer can enter configuration data specifying that if the state machine is in that state, the output should be acknowledged. In the example matrix 700, configuration data has been entered into some of the cells 704.For example, cell 704A contains configuration data indicating that if the state machine is in the "TRIPPED" state, the output OUT_D3 should be acknowledged; cell 704B contains configuration data indicating that if the state machine is in the "TRIPPED" state, the output TRANS_IN should not be acknowledged; and cell 704C contains configuration data indicating that if the state machine is in the "RESTORED" state, the output TRANS_OUT should be acknowledged.

[0083] If, in this particular example, the programmer does not enter any configuration data into cell 704, it can be assumed that the corresponding output is not to be acknowledged for that specific state. For example, cells 704D and 704E do not contain an X, indicating that if the state machine is in the "TRIPPED" state, the outputs OUT_D1 and OUT_D2 are not to be acknowledged. In other embodiments, the programmer can enter configuration data specifying that the state machine should not acknowledge certain outputs if it is in a particular state. Similarly, it may be possible to specify that for a particular state and output, it is irrelevant whether the output is acknowledged or not.

[0084] The programmer can enter configuration data into matrix 700 using a variety of techniques, including those well-known to professionals. For example, to enter configuration data into cell 704, the programmer can select cell 704 using a mouse, a directional pad, a touchscreen, etc. The user could then enter configuration data directly into cell 704, for example, using a keyboard. Alternatively, the programmer could select cell 704 and then make an "Edit," "Change," etc., selection from an action menu, or select an "Edit," "Change," etc. button. The user interface can then display a selection list to the programmer via an action menu, a window, a screen, etc.For example, the selection list might include an option to "Confirm Output," an option to "Disable Output Confirmation," and optionally, an option to "Irrelevant." The programmer can then select one of the options, for example, using a keyboard, mouse, D-pad, touchscreen, etc. If the programmer selects "Confirm Output," the configuration data can specify that the corresponding output should be confirmed for the selected state. For example, an "X," a "1," the word "TRUE," or the word "CONFIRM" might be displayed in the cell, and so on. If the programmer selects "Disable Output Confirmation," the configuration data can specify that the corresponding output should not be confirmed for the selected state.For example, the cell can remain empty, a "0" can be displayed in the cell, the word "FALSE" can be displayed in the cell, the words "VOIDE CONFIRMATION" can be displayed in the cell, etc.

[0085] Although the example matrix comprises 700 rows for six states and six outputs, similar matrices with other numbers of states and outputs can be used for SMFB. The number of states and outputs can be configured.

[0086] Once again with reference to Fig. 7, and as described previously, the SMFB data outputs can be set based on the current state after the current state has been determined (Block 366). For example, the data outputs can be set according to the configuration data that is entered into a matrix, such as matrix 700 from Fig. 13 were registered.

[0087] Fig. Figure 14 is a flowchart of an example routine 850, which can be used to confirm the appropriate outputs OUT_D1, OUT_D2, etc. In block 854, a variable z is set to one. In block 858, the output OUT_Dz is set to the value of the bit count z of an element of an array variable OUTPUT, to which the variable STATE points. Each element of the array OUTPUT can be a variable that specifies the values ​​of the outputs OUT_D1, OUT_D2, etc., for a corresponding state. For example, OUTPUT[1] can correspond to state 1, OUTPUT[2] can correspond to state 2, etc. Additionally, each bit of each element can correspond to one of the outputs OUT_D1, OUT_D2, etc. For example, bit 1 can correspond to OUT_D1, bit 2 can correspond to OUT_D2, etc. With reference to Fig. For example, in 13 the array OUTPUT would have 6 elements for the matrix 700, and the element OUTPUT[1] can be 0×06.

[0088] In block 862, the variable z is incremented, and in block 866, it can be determined whether the value of z is greater than the number of outputs OUT_D1, OUT_D2, etc. If z is not greater than the number of outputs OUT_D1, OUT_D2, etc., the routine can return to block 858. Otherwise, the routine can terminate.

[0089] In addition to the methods described above, configuration data for the SMFB can be entered via other types of graphical user interfaces. For example, configuration data can be entered via a graphical user interface similar to a state transition diagram. Fig. Figure 15 is an example state transition diagram 900 that could be used to configure an SMFB, such as the SMFB 200, as described in reference to Fig. As described in section 4, diagram 900 comprises a variety of graphical elements: 904, 908, 912, 916, 920, 924, 928, and 932. Elements 904, 908, and 912 each represent states 1, 2, and 3 of a state machine, respectively. Element 916 specifies that if the state machine is in state 1, it should transition to state 2 if INPUT 2 is confirmed. Element 920 specifies that if the state machine is in state 1, it should transition to state 3 if INPUT 3 is confirmed. Element 924 specifies that if the state machine is in state 2, it should transition to state 1 if INPUT 1 is acknowledged, and element 928 specifies that if the state machine is in state 3, it should transition to state 1 if INPUT 1 is acknowledged. Similarly, element 932 specifies that if the state machine is in state 3, it should transition to state 2 if INPUT 4 is acknowledged.

[0090] The state transition diagram 900 further comprises the transition-in elements 902, 903 and a transition-out element 905, which are associated with state 1; the transition-in elements 906, 907 and a transition-out element 909, which are associated with state 2; and a transition-in element 911 and the transition-out elements 913, 914, which are associated with state 3. In particular, if the state machine is in state 1 and INPUT 3 is acknowledged, the state machine is to execute the transition-out element 905, transition to state 3, and execute the transition-in element 911 of state 3. Furthermore, if the state machine is in state 2 and INPUT 1 is acknowledged, the state machine is to execute the transition-out element 909, transition to state 1, and execute the transition-in element 902. It is understood that the transition-in elements and / or the transition-out elements can be common for any states.For example, the transition-in elements 902 and 903 can be the same, causing the state machine to perform the linked transition-in action in response to the state machine transitioning to state 1 from either state 2 or state 3. As another example, the transition-out elements 913 and 914 can be the same, causing the state machine to perform the linked transition-out action in response to the state machine transitioning to either state 1 (in response to INPUT 1 being acknowledged) or state 2 (in response to INPUT 4 being acknowledged).

[0091] In general, a SMFB can be implemented by software, firmware, or hardware, or a combination of these. For example, an SMFB can be implemented by one or more of the controllers 12a, 16a, the I / O devices 24, the logic solver 50, and the devices 22, 23, 60, 62. As another example, an SMFB can be implemented by one or more of the workstations 18a and 20a. For example, the SMFB can be implemented by workstation 18a and / or workstation 20a as part of a simulation to test the operation of the process plant or to provide operator training. In some embodiments, the SMFB can be implemented by a processor configured according to software, by a programmable logic device, e.g.,a device that includes one or more of a gate array, a standard cell, a user-programmable gate array (FPGA), a PROM, an EPROM, an EEPROM, a programmable array logic (PAL), a programmable logic array (PLA), etc.

[0092] Each of blocks 404, 408, 412, 416, 420 and 458 from Fig. 8 can be implemented by software, firmware, or hardware, or a combination of software, firmware, and / or hardware. Although the flowcharts from Fig. Since sections 10 to 12 and 14 were described as routines, these flowcharts could be implemented by software, hardware, firmware or a combination of software, firmware and / or hardware.

[0093] Implementations of a user interface, such as those described above, can be implemented in whole or in part by a processor configured, for example, according to a software program. For instance, workstation 18a or 20a, or another computer, can implement the user interface described above in whole or in part. A software program for implementing implementations of a user interface can be stored as software on a physical medium, such as a hard disk, RAM, battery-backed RAM, ROM, CD-ROM, PROM, EPROM, EEPROM, DVD, flash memory, etc.or a memory such as RAM linked to the processor, but the person skilled in the art will readily understand that the entire program or parts thereof could alternatively be executed by a device other than a processor and / or be designed as firmware and / or dedicated hardware in a well-known manner.

[0094] Also revealed herein are the following items: 1) A physical medium that stores machine-readable instructions, comprising: - first code to provide a graphical user interface via a display device for configuring transitions between the state machine states of a state machine, wherein the graphical user interface specifies a first plurality of cells arranged in a matrix having a first dimension and a second dimension, wherein the positions along the first dimension specify the state machine states and their associated transition action identifiers, and the positions along the second dimension correspond to inputs of the state machine, such that the first plurality of cells defines input / state pairs and their transition actions based on the positions of the first plurality of cells with respect to the first and second dimensions; - second code to receive state transition data associated with a cell of the first plurality of cells via the graphical user interface, wherein the state transition data identifies a next state to which the state machine transitions according to the input / state pair defined by the cell; - third code to receive transition action data via the graphical user interface, wherein the transition action data identifies at least one transition action to be executed according to the state transition data; and - fourth code to store on a computer-readable medium the state transition data and the transition action data associated with a function block that implements the state machine in a process plant, so that the state machine transitions to the next state when a condition in the process plant matches the input / state pair associated with the cell. 2) Material medium according to subject matter 1) claim 14, wherein the transition action data identifies 1) a transition-off action to be performed when transitioning from the state of the state machine corresponding to the cell, and / or 2) a transition-in action to be performed when transitioning to the next state. 3) Material medium according to object 2), furthermore encompassing: - fifth code to display the first set of cells on the display device; and - sixth code to display in the cell an indication of the next state, an indication of the transition-out action and an indication of the transition-in action. 4) Material medium according to object 3), wherein the sixth code in the cell indicates the next state, the transition-out action and the transition-in action by: - Displaying the indication of the next state in a first subcell of the cell; - Displaying the transition-off action in a second sub-cell of the cell; and - Displaying the transition-in action in a third subcell of the cell. 5) Material medium according to item 3), wherein the fifth code specifies the first plurality of cells on the display device by displaying the matrix, the first dimension listing at least one row of cells and the second dimension listing a plurality of columns of cells, such that each of the at least one row of cells is associated with one of the inputs of the state machine, and each of the plurality of columns of cells is associated with one of the state machine states and with one of the transition action identifiers. 6) Material medium according to item 3), wherein the fifth code displays the first plurality of cells on the display device by displaying the matrix, wherein the first dimension displays at least one cell column and the second dimension displays a plurality of cell rows, such that each of the plurality of cell rows is associated with one of the state machine states and with one of the transition action identifiers, and each of the at least one cell column is associated with one of the state machine inputs. 7) Material medium according to one of the items 1) to 6), wherein a specific value of each of the inputs to the state machine is one of a logical one, a logical zero, a logical TRUE or a logical FALSE. 8) Material medium according to any of the items 1) to 7), wherein the graphical user interface further specifies a second plurality of cells associated with each function block, wherein each of the second plurality of cells corresponds to a respective output of a plurality of outputs of the function block and to a respective state machine state, and wherein the material medium further comprises: - fifth code to receive output configuration data associated with an additional cell of the second set of cells via the input device, wherein the output configuration data specifies an output value corresponding to the additional cell when the state machine is in the state machine state corresponding to the additional cell, and at least one output transition action associated with the additional cell. 9) Material medium according to one of the items 1) to 8), wherein the inputs of the state machine are linked to at least one of a process control system, a simulation of a process control system, a safety system and a simulation of a safety system. 10) Material medium according to one of the items 1), 2), 7) and 9), further comprising fifth code for receiving inputs to the state machine either from an additional functional block linked to the process plant or from an operator interface.

[0095] Although the invention is capable of various modifications and alternative designs, certain illustrative embodiments have been shown in the drawings and are described in detail here. It is understood, however, that the disclosure is by no means intended to be limited to the specific forms disclosed, but rather that the invention is intended to cover all modifications, alternative designs, and equivalents that fall within the spirit and scope of the disclosure as defined by the accompanying claims.

Claims

[1] A method for configuring, via a computer device comprising a display device and an input device, a functional block linked to a process plant, wherein the functional block is designed to implement a state machine, the method comprising the following steps: - Providing a graphical user interface displayed by the display device, wherein the graphical user interface specifies a first plurality of cells associated with the function block and arranged in a matrix having a first dimension and a second dimension, wherein the positions along the first dimension specify states of a state machine and associated identifiers of transition actions, and positions along the second dimension correspond to the inputs of the state machine, such that the first plurality of cells define input / state pairs and their transition actions based on the positions of the first plurality of cells with respect to the first and second dimensions; - Receiving state transition data associated with a cell of the first plurality of cells via the input device, wherein the state transition data identify a next state to which the state machine transitions according to a condition in the process plant corresponding to the input / state pair defined by the cell; - Receiving transition action data via the input device, wherein the transition action data identifies at least one transition action to be executed according to the state transition data; and - Storing the state transition data and transition action data on a computer-readable medium linked to the functional block, characterized by, that the transition action data identify at least one of 1) a transition-off action to be performed when transitioning from the state of the state machine corresponding to the cell, and 2) a transition-in action to be performed when transitioning to the next state, wherein the procedure comprises the following steps: - Displaying the first multitude of cells on the display device; and - Displaying an indication of the next state, an indication of the transition-out action, and an indication of the transition-in action in the cell, where displaying the indication of the next state, the indication of the transition-out action, and the indication of the transition-in action in the cell comprises the following steps: - Displaying the indication of the next state in a first subcell of the cell; - Displaying the transition-off action in a second sub-cell of the cell; and - Displaying the transition-in action in a third subcell of the cell. [2] Method according to claim 1, wherein displaying the first plurality of cells on the display device comprises displaying the matrix, wherein the first dimension lists at least one row of cells and the second dimension lists a plurality of columns of cells, such that each of the at least one row of cells is associated with one of the inputs of the state machines, and each of the plurality of columns of cells is associated with one of the states of the state machine and with one of the identifiers of the transition action. [3] Method according to claim 1, wherein displaying the first plurality of cells on the display device comprises displaying the matrix, wherein the first dimension lists at least one column of cells and the second dimension lists a plurality of rows of cells, such that each of the plurality of rows of cells is associated with one of the states of the state machine and with one of the identifiers of the transition action, and each of the at least one column of cells is associated with one of the inputs of the state machine. [4] Method according to any of the preceding claims, wherein a specific value of each of the inputs to the state machine is a logical one, a logical zero, a logical TRUE or a logical FALSE. [5] Method according to any of the preceding claims, wherein the graphical user interface further specifies a second plurality of cells that is linked to the function block, wherein each of the second plurality of cells corresponds to a respective output from a plurality of outputs of the function block and a respective state from the states of the state machine, and wherein the method further comprises the following step: - Receiving output configuration data associated with an additional cell of the second plurality of cells via the input device, wherein the output configuration data specifies an output value corresponding to the additional cell when the state machine is in the state of the state machine corresponding to the additional cell, and at least one output transition action associated with the additional cell. [6] Method according to any of the preceding claims, wherein the at least one transition action is to be performed by the functional block. [7] A method according to any one of the preceding claims, further comprising the following steps: - Receiving priority data associated with state machine inputs; and - Storing the priority data associated with the state machine inputs. [8] A method according to any one of the preceding claims, further comprising the following steps: - Receiving data indicating whether one or more of the state machine's inputs should be ignored by the state machine; and - Storing the data that indicates whether one or more of the inputs to the state machine should be ignored by the state machine. [9] Method according to any of the preceding claims, wherein the inputs of the state machine are linked to at least one of a process control system, a simulation of a process control system, a safety system and a simulation of a safety system. [10] Method according to any of the preceding claims, further comprising receiving the inputs of the state machine from an additional functional block linked to the process plant or from an operator interface. [11] Material carrier which has stored machine-readable instructions which, when executed on a processor, perform a method according to any one of claims 1-10.

Images