HK1059128B - Custom function blocks for use with process control systems - Google Patents

Description

Custom function block for a process control system

Technical Field

The present invention relates generally to process control systems and, more particularly, to a method and technique for enabling a user or operator of a process control system to create custom function blocks for performing control activities in the process control system.

Background

Modern process control systems are typically microprocessor-based Distributed Control Systems (DCS). A conventional DCS configuration includes one or more user interface devices (e.g., workstations) connected by a data bus (e.g., ethernet) to one or more controllers. The physical location of these controllers is typically proximate to a process being controlled and is coupled to a number of electronic monitoring devices and field devices (e.g., electronic sensors, transmitters, current-to-pressure transducers, valve positioners, etc.) located throughout the process.

In a conventional DCS, control tasks are distributed by providing a control algorithm within each controller. The controllers independently execute control algorithms to control field devices coupled to the controllers. This decentralization of control tasks makes the overall system more flexible. For example, if a user wants to add a new process or a new portion of a process to the DCS, the user may add an additional controller (with a suitable control algorithm) connected to the appropriate sensors, actuators, etc. Alternatively, new control parameters or control algorithms may be downloaded from the user interface to an appropriate controller via the data bus, for example, if the user wants to modify an existing process.

To provide improved modularity and inter-manufacturer compatibility, process control manufacturers have recently moved further towards control dispersion within the process. These recently adopted methods are based on smart field devices capable of communicating with each other and/or controllers using open protocols (e.g., protocols such as HART ®, PROFIBUS ®, WORLDFIP ®, Device-Net ®, CAN, and Fieldbus). These smart field devices are essentially microprocessor-based devices (e.g., sensors, actuators, etc.), and in some cases, these devices, like Fieldbus devices, also perform control loop functions that are traditionally performed by DCS controllers. Because some smart field devices provide control capabilities and communicate using an open protocol, field devices produced by various manufacturers can communicate with each other over a common digital data bus and can interoperate to implement a control loop without the intervention of a conventional DCS controller.

As is well known, process control system controllers and smart field devices (such as Fieldbus devices), for example, may include one or more function blocks that perform multiple control functions or portions of a control function. For example, the function blocks may perform analog input functions, analog output functions, proportional-integral-derivative (PID) control functions, or any other desired control functions. The function blocks may be communicatively coupled to other function blocks within the controller or smart field device or to function blocks within other controllers or smart field devices to perform any desired control functions. For example, an analog input block may be used to monitor fluid flow via a flow sensor, and a PID block may process one fluid flow value provided by the analog input block to provide a responsive signal via an analog output block to an actuator that modulates the position of a valve plug. In this way, the function blocks may be communicatively interconnected to form a PID based control loop that controls the flow of fluid through the valve.

Process control manufacturers or providers typically provide one or more standard libraries to system users, which include various different predefined function blocks. Generally, predefined function blocks may be selected and combined with one another as directed by a system user to implement an overall process control scheme. Some process control manufacturers also provide graphical user interfaces that enable users to visualize the logical relationships between the various function blocks, which greatly facilitates the creation of an overall process control scheme, especially where the process control scheme is complex.

Once the user has created the overall process control scheme by selecting which function blocks are to be executed and defining the logical relationships between the selected function blocks, one or more of the function blocks may be instantiated within the process control system to execute the overall process control scheme. Because the predefined function blocks are typically instantiated within controllers and/or smart field devices distributed throughout a process control system, the predefined function blocks may be executed in a synchronized manner at a relatively high speed.

If a process control scheme requires the execution of a particular function, application or algorithm within a standard library of function blocks that the control system manufacturer or provider has not yet provided, a system user will typically create and instantiate a separate program that performs that particular function, application or algorithm. In practice, the stand-alone program is typically created and instantiated within a workstation or some other computer system, for example, which is communicatively coupled to controllers and other devices distributed throughout a process control system via a communication network (e.g., a local area network). As a result, the integration of a separate program that performs a particular function, application, or algorithm with the overall process control scheme requires that the separate program communicate with other portions of the overall control program via a communication network.

The difficulty of integrating a process created or defined by a particular user executing a particular function, application or algorithm with the overall process control scheme is exacerbated because communication between the workstation and the controller or some other process control system device communicatively coupled to the local area network is typically based on a dedicated message format or protocol that is not known to the system user. To alleviate this integration difficulty, some process control manufacturers may allow communication between their control processes and other processes or systems using, for example, communication based on a common data language (e.g., ole (opc) for process control). For example, common data languages (e.g., OPC) are typically based on extensible markup languages (e.g., XML) or similar languages that enable system users to package information or messages from their particular creation or customization process (performing a particular function, application, or algorithm) in a schema or format that can be interpreted by the system executing the overall process control scheme. Likewise, the user-defined custom processes may utilize knowledge about patterns to interpret and process information or messages received from the process control system that have been packaged or formatted using an extensible markup language. In this manner, a process control manufacturer or provider may enable a user to integrate additional systems and processes, some of which may be executed by the user to perform a particular function, application, or algorithm without revealing the specific message formats or protocols used in communicating between the execution workstation or other computer system and the controllers distributed throughout the process control system.

Known techniques for enabling a user-defined process or system or some other process or system to integrate with or communicate with an overall process control system generally do not allow direct communication between the user-defined process and the controllers and/or smart field devices within the process control system. Rather, these known techniques (some of which are XML-based) require a user-defined process or system to communicate with controllers and/or smart field devices via a workstation or other computer system (coupled to the controllers and other devices via a communication network). Unfortunately, the speed of communication over a communication network (e.g., a LAN) is relatively slow, especially when compared to communication between a controller and a smart field device. Additionally, the use of extensible markup language or similar languages to facilitate the exchange of information between controllers and other devices within a process control system and a user-defined process or system creates additional communication costs. This additional communication cost also represents an effective speed at which information or messages may be communicated between the user-defined process or system and the process control system controller and/or other devices.

Another disadvantage of having to communicate information between the user-defined process and the overall process control routine executed by the process control system is that: the information or messages provided or used by the user-defined process or system are typically not synchronized with the activities performed by the controller and/or the intelligent site connected to the controller. Thus, in most, if not all, process control systems, communication via a communication network communicatively coupling workstations to controllers has relatively low data throughput and is not synchronized with communication between the controllers and field devices. For some applications, the implementation of a user-defined process or system may become impractical or (in some cases) impractical if not impossible to integrate or couple a particular user-defined process or system more closely with the operation of the overall process control system, for example, by expediting the exchange of information between the two systems and synchronizing the two systems.

Disclosure of Invention

The custom function blocks and the methods of creating the custom function blocks described herein enable a process control system user to more closely integrate or couple specific functions, applications, algorithms, and/or processes (which may be user-defined) with the operation of the overall process control system. In particular, the custom function block creation techniques described herein may use predefined libraries that contain templates, routines, procedures, tables, etc. (which a user may select, modify, and/or combine to assemble, generate, or define one or more libraries of function blocks, each of which may contain one or more custom function blocks). A text editor, graphical user interface, function block wizard, or virtual expert, etc. may be used to facilitate the generation of the custom function blocks.

The predefined libraries used by the systems and techniques described herein may include a variety of different function block components some of which may be required by the process control system to properly integrate a function block into an overall process control routine and others of which may not be required. A user may employ the systems and techniques described herein to create, generate, or define one or more custom function blocks that may implement functions, applications, algorithms, or programs not provided by a process control system provider or manufacturer in a standard function block library. In general, the user selects, from a predefined library containing function block components, modifies (if necessary) the desired function block components, and includes the selected components in the custom function block. The user may also include additional functions or algorithms executable by the custom function block by entering appropriate additional code or software into the custom function block definition.

Using the systems and techniques described herein, a user is able to perform custom functions, applications, algorithms, or the like in a standard function block library that have not been provided by a process control system provider or manufacturer by creating new or custom function blocks that are similar or identical in structure to the function blocks provided in the standard function block library. As a result, custom functions (i.e., custom function blocks) may be compiled and used in the process control system as standard function blocks. In this manner, the processes, applications, algorithms, etc. defined within the custom function blocks may communicate within the overall process control routine at a relatively high rate of speed, since the custom functions, applications or programs do not necessarily communicate via workstations and LANs using, for example, extensible markup language (XML). Further, because custom function blocks may be compiled and downloaded into controllers and/or smart field devices in a manner similar or identical to standard function blocks, communication between custom function blocks and other standard function blocks within a process control system may be conducted in a synchronized manner (i.e., the operation of the custom function blocks may be scheduled along with the operation of the standard function blocks).

According to one aspect, a method of creating a function block for a process control system may select an initialization routine from a plurality of source files, may select a periodic execution routine from a plurality of source files, and may select a write check routine from a plurality of source files. Additionally, the method may associate an initialization routine, a periodic execution routine, and a write check routine with the function block, and may modify one of the initialization routine, the periodic execution routine, and the write check routine to include a process that is not provided to the process control system.

According to another aspect, a method of creating function blocks for a process control system may combine a plurality of files from a set of files created by a provider of the process control system to form one file associated with a function block; also, a file of the plurality of files within the file associated with the function block may be modified to include a process not included within the set of files.

According to another aspect, a system for creating function blocks for a process control system may include a computer-readable medium, a first software and a second software. First software is stored on a computer readable medium and is adapted to be executed by a process control system to select an initialization routine from a plurality of source files; second software is stored on a computer readable medium and is adapted to be executed by the process control system to select a routine for periodic execution from a plurality of source files. The system may further include a third software, a fourth software, and a fifth software. Third software is stored on the computer readable medium and is adapted to be executed by the process control system to select a write check routine from the plurality of source files; fourth software is stored on the computer readable medium and is adapted to be executed by the process control system to associate the initialization routine, the periodic execution routine, and the write check routine with the function blocks; the fifth software is stored on the computer readable medium and is adapted to be executed by the process control system to modify one of the initialization routine, the periodic execution routine, and the write check routine to include a process not provided within the process control system.

According to yet another aspect, a method of incorporating a custom function block within a process control system may generate the custom function block by combining a plurality of files from a set of files created by a provider of the process control system to form a source code file associated with the function block; also, a file of the plurality of files within the source code file may be modified to include a process not included within the set of files. The method may also compile and concatenate the source code file to form a compiled/concatenated custom function block file; and, this compiled/connected custom function block file may be passed to the provider of the process control system. Further, the method may validate the compiled/connected custom function block file: a security measure may be attached to the compiled/linked custom function block file to form an active custom function block file; and may communicate the validated custom function block file to a user of the process control system. Additionally, the method may incorporate the validated custom function block file into the process control system.

According to another aspect, a method of using a custom function block to communicate information from a data source to the custom function block, process information from the data source according to a function within the custom function block, and communicate at least some of the processed information to a process control system application.

Drawings

FIG. 1 is an exemplary block diagram generally depicting one architecture and generation technique for custom function blocks; and the number of the first and second groups,

FIG. 2 is an exemplary flow chart depicting one method by which a control system provider or manufacturer may control the application of custom function blocks within its control system.

Detailed Description

The custom function blocks and the methods of creating the custom function blocks described herein enable a process control system user to tightly integrate or couple specific functions, applications, algorithms, and/or processes that may be defined by the user with the operation of the overall process control system. In particular, the custom function block creation techniques described herein may use predefined libraries that contain templates, routines, procedures, tables, etc. (which a user may select, modify, and/or combine to assemble, generate, or define one or more libraries of function blocks, each of which may contain one or more custom function blocks). A text editor, graphical user interface, function block wizard, or virtual expert, etc. may be used to facilitate the generation of the custom function blocks.

The predefined libraries used by the systems and techniques described herein may include a variety of different function block components some of which may be required by the process control system to properly integrate a function block into an overall process control routine and others of which may not be required. A user may employ the systems and techniques described herein to create, generate, or define one or more custom function blocks in a library of standard function blocks that may execute functions, applications, algorithms, or processes not provided by a provider or manufacturer of a process control system. In general, the user selects, from a predefined library containing function block components, modifies (if necessary) the desired function block components, and includes the selected components in the custom function block. The user may also include additional functions or algorithms to be performed by the custom function block by entering the appropriate additional code or software into the custom function block definition.

Using the systems and techniques described herein, a user is able to perform custom functions, applications, algorithms, or the like in a standard function block library that have not been provided by a process control system provider or manufacturer by creating new or custom function blocks that are similar or identical in structure to the function blocks provided in the standard function block library. As a result, custom functions (i.e., custom function blocks) may be compiled and used in the process control system as standard function blocks. In this manner, the programs, algorithms, etc. defined within the custom function blocks may communicate within the overall process control routine at a relatively high rate of speed, because the custom functions or programs do not necessarily communicate via workstations and LANs using, for example, extensible markup language (XML). Further, because custom function blocks may be compiled and downloaded into controllers and/or smart field devices in a manner similar or identical to standard function blocks, communication between custom function blocks and other standard function blocks within a process control system may be conducted in a synchronized manner (i.e., the operation of the custom function blocks may be scheduled together with the operation of the standard function blocks).

FIG. 1 is an exemplary block diagram 100 generally depicting one architecture and generation technique for a custom function block 102. As shown in FIG. 1, the custom function block 102 includes an initialization process or routine 104, a periodic execution routine 106, and a write check routine 108. The routines 104 and 108 may be generally referred to as "customizing the behavior or method of the function block 102". The routines 104 and 108 may include various attributes that use public data 110 and/or private data 112. These attributes, and thus the public data 110 and/or private data 112 associated therewith, may be obtained from a process control system (not shown) in which custom function blocks may be instantiated via an attribute table 114. Further, as shown in FIG. 1, and as described in more detail below, custom function blocks 102 may be generated or defined using a set of header files 116, a set of source files 118, and/or a set of library files 120. In addition, the custom function block 102 may have a name 122 associated therewith and may be part of a custom function block library 124 that includes a plurality of custom function blocks 126.

The initialization routine 104, when executed, is adapted to initialize the public data 110 and the private data 112 associated with the custom function block 102. The initialization value of the data 110 and 112 is preferably, but not necessarily, a default or initial value, in which case the initialization routine 104 is executed once before the routine 106 is executed periodically. Of course, the initialization routine 104 may be executed more than once, if desired, to meet the requirements of a particular application or function desired by the user.

The write check process or routine 108, when executed, is adapted to validate data of the common data 110 written to the custom function block 102 from an external source (i.e., outside of the function block 102). Write check routine 108 is preferably invoked in response to an external source attempting to write data or information to common data 110. The write check routine 108 may determine whether the current state of the functional block 102 allows an external write operation to be performed on the target data, whether the target data may be written by an external source, and/or whether the information or data being written to the target data is within one or more predetermined, acceptable limits. For example, block 102 may be currently using the target data and allowing an external source to change the target data before completing a process, series of steps, etc., which may result in unreliable or erroneous results. Of course, any other different or additional types of checks may be performed by write check routine 108.

The routine 106, when executed, is adapted to perform a particular function or algorithm that a user desires to implement within the control system, which may not be available via standard function blocks provided by the control system provider or manufacturer. For example, the routine 106 may include a mapping function or algorithm that enables information or data to be exchanged between the control system and some other application, system or device with which the control system would otherwise be unable to communicate. Alternatively or additionally, the routine 106 may include a profitability calculation and/or some other financial calculation related to a process control system not normally provided within a standard functional block. Of course, the number and types of functions or algorithms that may be included within the periodically executing routine 106 is virtually limitless. In practice, the particular function or algorithm performed by the periodic execution routine 106 generally defines the overall behavior of the custom function block 102, and thus, the name of the custom function block 102 may reflect that particular behavior. For example, if the routine 106 includes a profitability calculation function or algorithm, the function block name 122 may be "FB _ PROFICALC" to reflect that function or algorithm.

The routine 106 may include algorithms that use public data 110 and/or private data 112. Although the common data 110 may be used by any custom or standard function block illustrated within the control system, some or all of the common data 110 may be dedicated to the custom function block 102. For example, the common data 110 may include external data of the common data 110 that the custom function block 102 passes from an external data area (i.e., any data area outside of the custom function block 102) to the custom function block 102. For example, the public data 110 may also include data obtained by the periodic execution routine 106 during execution using the public data 110 and/or the private data 112.

On the other hand, the private data 112 is data that is not available to other functional blocks. In general, private data 112 is used to track historical block execution information or data related to custom block 102 and may be used in subsequent executions of block 102 or may be used to control the behavior of block 102 in response to one or more exception events. Similar to the public data 110, the private data 112 may include external data that the periodically executing routine 106 passes from the external data area to the private data 112 and/or may include data that the periodically executing routine 106 obtains from the public data 110 and/or the private data 112.

The public data 110 and the private data 112 may be of any desired type of computation. For example, floating point array, 8-bit, 16-bit, and/or 32-bit signed or unsigned integers (single or double precision), ASCII strings, unicode strings, and the like may be used in any desired combination. In addition, each data item within the public data 110 and the private data 112 may be provided with a name that the periodic execution routine 106 or another periodic execution routine within another functional block may reference.

The attribute table 114 maps the attributes used by the custom function block 102 to information or data within the control system in which the custom function block 102 is instantiated. In particular, each attribute defined within the custom function block 102 may include, for example, a pointer referencing a particular row or portion of the attribute table 114 (mapping the attribute to a data source within the control system). Although there is preferably a unique correspondence between each attribute in the custom function block 102 and each row of the attribute table 114, other function blocks may also include pointers that use the mapping function provided by the attribute table 114. In other words, each row within the attribute table 114 may have a "one-to-many" relationship such that each row of the attribute table 114 may be referenced or pointed to by more than one function block.

To construct, create, or generate the custom function block 102, a user may use a text editor, a graphical user interface, or any other technique that enables viewing and processing of and/or representation of software source code files. As shown in FIG. 1, a user may combine files selected from a header file 116, a source file 118, and a library file 120 to create a custom function block 102.

The header file 116 includes definitions of different types of structures and invocation interfaces that may be used by function blocks within the target process control system (i.e., the process control system in which instances of the custom function block 102 are to be instantiated). Library file 120, on the other hand, includes helper routines that may be needed to perform routine activities within the target control system. For example, the library file 120 may include one or more routines that facilitate establishing a desired operating mode within the target process control system.

The source files 118 are software source code files that include the initialization routine 104, the periodic execution routine 106, and the write check routine 108. For example, the source files 118 may be based on a high-level programming language (e.g., C + +), or may be based on any other desired programming language. For example, to facilitate a user in creating custom function blocks (e.g., custom function blocks 102), each source file 118 may include exhaustive notes that clearly explain the purpose and function of the various software code portions contained within the source file 118. For example, the annotations may clearly indicate which source files or portions of the source files 118 are responsible for each routine in the routines 104 and 108. Additionally, the annotations within the source files 118 may also explicitly indicate where the user should insert source code for the custom algorithms or functions required within the periodic execution routine 106. Additionally, these annotations may suggest the use of one or more helper routines contained within library file 120, and may also suggest or explain how those helper routines may be integrated within custom function block 102. Preferably (but not necessarily), the source file 118 also includes references or pointers to some of the header files 116 that may be needed to create, compose, or generate the custom function block 102.

Although FIG. 1 depicts a single custom function block 102 being generated, created, or composed using header files 116, source files 118, and/or library files 120, multiple custom function blocks may be created if desired. Where multiple custom function blocks are created, these function blocks may be collected within one or more libraries of custom function blocks.

Furthermore, it is important to recognize that: the particular programming language used for the header file 116 and the source file 118 may be selected to facilitate the user's generation of custom function blocks. For example, C + + is particularly well suited for programming using object-oriented techniques, which provides an intuitive framework for generating software algorithms for relatively complex process control systems. Of course, any other programming language and/or programming technique may be used.

The contents of header file 116, source file 118, and library file 120 are configured to meet the specific requirements of the target control system. In other words, for example, the library file 120 may include helper routines that perform activities (e.g., mode control activities, status activities, debugging activities, etc.) in a manner compatible with the particular requirements of the target control system. Likewise, header 116 and source files 118 may comprise source code that, when compiled, linked and executed by the control system, will be compatible with the specific requirements of the target control system.

As such, the custom function blocks described herein may be used to tightly integrate or couple specific functions, applications, algorithms, and/or routines that may be defined by a user with the operation of the overall process control system. In particular, a control system user or operator may create, or define one or more custom function blocks or libraries of custom function blocks in order to add new functionality to the control system (a control system manufacturer or vendor would not otherwise provide the control system within a standard function block library). In particular, a process control system user or operator may create or define one or more custom function blocks that enable the process control system to perform analyses or calculations that cannot be performed using standard function blocks provided by the control system manufacturer or vendor. For example, a process control system user or operator may create a custom function block that performs a profit calculation based on one or more parameter values within the process control system. Of course, one or more custom function blocks may be defined or created by a system user or operator to perform any required calculations based on parameter values obtained from within the process control system and (as described in more detail below) based on parameter values obtained from other devices and/or systems (which may not generally be integrated with the process control system and, thus, may not generally be in communication with the process control system).

The custom function blocks described herein may be used to update the functionality of an older process control system. For example, advanced control capabilities may be added to an older control system that provides only basic control capabilities by creating custom function blocks that perform these advanced control functions. Also, for example, the custom function blocks described herein may be used to update or increase the functionality of a basic control system or controller (e.g., a programmable logic controller). For example, more functionality may be added to a base controller or control system by setting up a custom function block layer that is interposed between the base controller or control system and another, more complex process control system, operator terminal, or the like.

Alternatively or in addition, a system user or operator may create custom function blocks or libraries of custom function blocks that enable the process control system to interface or integrate with other devices, equipment, and/or systems provided by other manufacturers. If the custom function blocks described herein are used to interface or integrate a process control system associated with one manufacturer or supplier with a system or device associated with another manufacturer or supplier, the custom function blocks may be defined or created using the process control system to transmit, map, translate, and/or reformat data or parameters provided by the other system or device for use by the process control system. Likewise, custom function blocks may also be used to transmit, map, translate, and/or reformat data or parameters provided by a process control system for use by other systems or devices.

For example, the custom function blocks described herein may be used to link a function block associated with a first process control system to a function block associated with a second process control system, where the first and second process control systems may be provided by different manufacturers or vendors. In this way, for example, the PID control loops within each of the first and second process control systems can be concatenated. Of course, the custom function blocks described herein may be used to create more complex links between multiple function blocks associated with multiple different process control systems. For example, two or more function blocks associated with different respective control systems, devices or equipment may be communicatively linked to each other to perform one or more process control activities.

It is important to realize that: in contrast to previous systems and techniques, the custom function blocks described herein enable function blocks of disparate origin to be linked together. In other words, function blocks associated with a Fieldbus system may be linked to function blocks associated with, for example, a PROVOX system via one or more custom function blocks. As described above, the custom function blocks described herein provide a standard shell or parameter interface that can be used to transfer information from one control system or device to another in a seamless manner. For example, the conventions associated with the "mode" parameter, the "status" parameter, and the BLOCK _ ERR parameter of a Fieldbus function BLOCK may be distinct from the conventions and/or corresponding parameters associated with a non-Fieldbus function BLOCK. One or more of the custom function blocks described herein may be created to map, translate, and/or eliminate data or information being communicated between Fieldbus function blocks and non-Fieldbus function blocks. In this way, for example, Fieldbus parameters (e.g., mode, status, and BLOCK _ ERR) may be mapped to or associated with appropriate parameters having non-Fieldbus function BLOCKs.

The custom function blocks described herein also enable applications and algorithms external to (i.e., not executed as part of, or integrated with) the process control system implementation to be integrated with the process control system implementation in a compact or seamless manner. Because the custom function blocks described herein are processed or used as standard function blocks, the custom function blocks enable external systems, applications, or algorithms to appear as part of the process control system software and enable the execution of the external systems, applications, or algorithms to be synchronized with the execution of the overall process control scheme.

The tight or seamless integration of external systems, applications, or algorithms with the process control system via the custom function blocks described herein enables these external systems, applications, or algorithms to be integrated with alarm management activities performed by the process control system, enabling a system user or operator to interface with the custom function blocks and (thus) with the external systems, applications, or algorithms to which these custom function blocks correspond to use standard configuration tools, debugging tools, simulation tools, etc. provided with the process control system. For example, a condition monitoring application (e.g., a rotating equipment monitoring application) may be integrated with a process control system via one of a plurality of custom function blocks so that a device alarm may be established within the process control system using a parameter monitored by the condition monitoring application. Moreover, the integration of external systems, applications, or algorithms using the custom function blocks described herein enables these external systems, applications, or algorithms to participate in redundant functions provided by the process control system and facilitate the observation of information related to function blocks associated with the external systems, applications, or algorithms (using operator interfaces and/or file management systems provided within the process control system). In addition, tight integration between the process control system and external systems, applications, or algorithms that may be provided by the custom function blocks described herein may be used to facilitate management of the process control system state during configuration downloads. For example, a custom function block associated with an external system, application or algorithm may be used to save the last value associated with the external system, application or algorithm during download.

As such, the custom function blocks described herein may be communicatively interposed between process control system applications and data sources. In particular, information from the data source (possibly process control information) may be communicated to a custom function block that may process at least some of the information from the data source according to a function therein. At least some of the processed information may then be communicated to a process control system application. The data source may be a function block, a device, or a parameter associated with the process control system application. Alternatively, the data source may be a system, a device, an algorithm, or an application external to the process control system application.

The processing of information received by the custom function block from the data source may include: some of the information received from the data source and/or some of the information that has been processed is mapped to one or more parameters related to or used by the process control system application. Alternatively or in addition, the custom function block may calculate a value for a parameter associated with the process control system application. The computations performed by the custom function blocks may be computations that are not normally performed or computations that cannot be performed without the use of the custom function blocks described herein. As such, the custom function blocks described herein may generally be used to communicate information between process control system applications and data sources based on the functions performed by the custom function blocks. In this manner, the custom function blocks described herein enable efficient integration of data sources external to the process control application with the process control application. If desired, the custom function blocks described herein may calculate a value based on information received from a data source and may associate that value with a parameter used by a process control system application (associated with the function block). More generally, for example, the custom function blocks described herein may perform one or more functions (e.g., data mapping functions, data conversion functions, data translation functions, etc.).

FIG. 2 is an exemplary flow chart 200 depicting one method by which a control system provider or manufacturer may control the application of custom function blocks within its control system. At block 202, for example, a control system user or operator may generate, create, or compose a custom function block (e.g., custom function block 102 shown in FIG. 1). A graphical user interface, text editor or the like may facilitate a user to create custom function blocks, for example, that enable the user to click and drag icons (representing parts of function blocks from library files or other files) to assemble the icons and, thus, the files they represent to form a function block. In addition, the user can edit or modify the source code file to include a particular function, algorithm, or process that is not provided by the standard function block.

At block 204, the completed source code files generated, created, or composed at block 202 may be compiled and concatenated to create one or more corresponding object code files (e.g., one or more Dynamic Link Library (DLL) files). Preferably (but not necessarily), the user may perform the compilation and linking of one or more source code files or by some other entity, if desired. At block 206, one or more compiled and linked source code files associated with the custom function block may be communicated to a provider of the target process control system. The provider may be an installer, a manufacturer, and/or any entity other than a user that is associated with the target process control system. Further, for example, the transfer of the compiled and connected source code file or files may be performed using any desired technique, e.g., electronic transmission via a wireless and/or hardwired communication network, which may include the use of the internet, transmission via some tangible storage medium, such as a storage disk or optical disk or other device, transmission via a printed hard copy, etc.

At block 208, the entity receiving the compiled and concatenated source code of the custom function block may verify: the custom function block will function properly within the target control system. The receiving entity may also determine: the custom function block, when executed, will not violate the terms and conditions of any license agreements that may be valid between the receiving entity and the entity responsible for creating the custom function block. If the custom function block is not valid, block 210 passes control to block 212, where the user may be notified to: the custom function block may not meet the licensing requirements and/or the custom function block may not function properly within the target process control system.

On the other hand, if the custom function block is valid (i.e., the permissions and/or operational requirements have been met or have not been violated), block 210 passes control to block 214. At block 214, the entity receiving the compiled and concatenated source code file of the custom function block may attach or add a digital signature to the compiled and concatenated custom function block file. Of course, any other type of security or authentication measures may be used instead of the digital signature. Alternatively, the digital signature or other security/authentication measures may be provided in a separate digital file, which may be embodied as a separate storage device or medium.

At block 216, the validated custom function block file is passed back to the user or entity responsible for creating or composing the custom function block. As described above, the custom function block file may be passed back using a digital signature or some other security measure. With respect to file transfer at block 206, file transfer at block 216 may be performed using any desired communication technique, including wireless and/or hardwired electronic transfer.

At block 218, the user or entity responsible for creating the custom function block may incorporate the custom function block into the target control system so that the system user can select and use the custom function block in a manner similar or identical to the manner in which processes, algorithms, etc. for process control may be designed and executed using standard function blocks. Preferably, but not necessarily, the custom function blocks to be used as published or product function blocks would follow the technique illustrated by way of example in fig. 2. Thus, the techniques illustrated by way of example in FIG. 2 will not necessarily be used to perform design development within a debug mode or some other development mode. In this way, the user is free to experiment in the process of developing a control system process using custom function blocks without having to engage in time-consuming file transfer, verification processes, etc. However, once a user has developed a custom function block or a library of custom function blocks to be incorporated into a control system and used for published or product capabilities, the user may be forced to follow a procedure similar or identical to that shown and described in connection with FIG. 2.

Although the technique depicted by way of example in FIG. 2 is described in connection with the creation and verification of a single custom function block, the technique depicted in FIG. 2 is generally more applicable. For example, the techniques shown in FIG. 2 may be employed at substantially the same time to create and validate multiple custom function blocks. Further, some or all of the custom function blocks in the plurality of custom function blocks may be contained within a single library or multiple libraries, if desired.

For example, by way of example only, the custom function blocks and methods of creating custom function blocks described herein may be used to facilitate an authentication process (e.g., an authentication process that may be required by the Food and Drug Administration (FDA)). Furthermore, the custom function blocks and creation techniques described herein enable custom function blocks to be developed and distributed in a compiled fashion, if desired, thereby making it more difficult, and perhaps impossible, for an entity other than the creator of the function block to reverse-supervise or determine how the custom function blocks function. As a result, the custom function blocks described herein may be developed and distributed in a compiled manner to enable developers to maintain patenting of the developed function blocks.

If implemented in software, the functional blocks and software routines discussed herein may be stored in any computer readable memory (e.g., on a magnetic disk, laser disk, or other storage medium) in the RAM or ROM of a computer, controller, field device, or the like. Also, the software may be delivered to a user or device via any known or desired transmission method, including over a communications channel such as a telephone line, the internet, etc., for example.

The present invention has been described with reference to particular examples (which are intended to be illustrative only and not to be limiting), but it will be apparent to those of ordinary skill in the art that: changes, additions, or deletions may be made to the disclosed embodiments without departing from the spirit and scope of the invention.

Claims (19)

1. A method of creating a function block for a process control system, comprising:

selecting an initialization routine from a plurality of source files;

selecting a routine for periodic execution from a plurality of source files;

selecting a write check routine from a plurality of source files;

associating an initialization routine, a periodic execution routine, and a write check routine with the function block; and the number of the first and second groups,

one of the initialization routine, the periodic execution routine, and the write check routine is modified to include a process that is not provided to the process control system.

2. The method of claim 1, further comprising: a header file is selected from a plurality of header files and associated with a function block.

3. The method of claim 1, further comprising: a library file is selected from a plurality of library files and associated with a function block.

4. The method of claim 1, wherein the periodically executed routine comprises a pointer to a table of attributes associated with the function block.

5. The method of claim 1, further comprising: data used by the functional block is defined as one of private data and public data.

6. The method of claim 1, wherein the step of modifying one of the initialization routine, the periodic execution routine, and the write check routine to include a process not provided to the process control system comprises: a graphical user interface is used.

7. The method of claim 1, wherein the step of modifying one of an initialization routine, a periodic execution routine, and a write check routine to include a process not provided to the process control system comprises: a software instruction in a high-level programming language is added to the routine for periodic execution.

8. A method of creating a function block for use in a process control system, the method comprising:

combining a plurality of function block components from a set of files created by a provider of a process control system to form a file associated with a function block; and the number of the first and second groups,

one of a plurality of function block components within the file associated with the function block is modified to include a process not included within the set of files.

9. The method of claim 8, wherein the step of combining a plurality of function block components from a set of files created by a provider of the process control system to form a file associated with the function block comprises: source and header files suitable for execution by the process control system are combined to perform one of a block initialization activity, a periodic execution activity, and a write check activity.

10. The method of claim 9, wherein the step of combining a plurality of function block components from a set of files created by a provider of the process control system to form a file associated with the function block further comprises: a library file is combined with source and header files.

11. The method of claim 8, further comprising: an attribute table is associated, the attribute table having at least one attribute for use by one of a plurality of function block components associated with a function block.

12. The method of claim 8, wherein the step of combining a plurality of function block components from a set of files created by a provider of the process control system to form a file associated with the function block comprises: each of the plurality of function block components is selected using one of a graphical user interface and a text editor.

13. The method of claim 8, wherein the step of combining a plurality of function block components from a set of files created by a provider of the process control system to form a file associated with the function block comprises: a first function block component containing a function block initialization routine, a second function block component containing a periodic execution routine, and a third function block component containing a write check routine are selected.

14. The method of claim 13, wherein the step of selecting the first, second and third function block components comprises: first, second, and third function block components are selected from a plurality of source files.

15. The method of claim 8, further comprising: an attribute of a function block is associated with information within the process control system via an attribute table using a pointer.

16. A method of incorporating a function block within a process control system, the method comprising:

generating function blocks by combining a plurality of files from a set of files created by a provider of a process control system to form a source code file associated with the function blocks and by modifying one of the plurality of files within the source code file to include a process not included within the set of files;

compiling and linking the source code file to form a compiled/linked function block file;

communicating the compiled/linked function block file to a provider of the process control system;

validating the compiled/linked function block file;

attaching a security measure to the compiled/linked function block file to form a validated function block file;

transferring the validated function block file to a user of the process control system; and the number of the first and second groups,

the validated function block file is incorporated into the process control system.

17. The method of claim 16, wherein the step of communicating the compiled/linked function block file to a provider of the process control system comprises: the compiled/linked function block files are transferred using one of wireless and hardwired communication techniques.

18. The method of claim 16, wherein the step of validating the compiled/linked function block file comprises: it is determined whether the function block complies with one of the licensing requirements and operational characteristics of the process control system.

19. The method of claim 16, wherein the step of attaching security measures to the compiled/linked function block file to form a validated function block file comprises: a digital signature is associated with the functional block.