Method for generating fault tree

The system automatically generates fault trees from design documents and ladder programs, addressing inefficiencies in existing methods by constructing fault trees without past failure data, thus reducing design time and costs while improving maintainability and support efficiency.

JP2024169347AActive Publication Date: 2024-12-05HITACHI LTD
View PDF 3 Cites 0 Cited by

Patent Information

Application Number
JP2024080165
Authority / Receiving Office
JP · JP
Patent Type
Applications
Current Assignee / Owner
Priority Date
2023-05-23
Filing Date
2024-05-16
Publication Date
2024-12-05
Estimated Expiration
2044-05-16

AI Technical Summary

Technical Problem

Existing fault tree generation methods require significant time and resources, especially for newly installed equipment or lines, as they rely on accumulated past failure data and manual collaboration between mechanical and electrical engineers, which is inefficient and resource-intensive.

Method used

A system that automatically generates fault trees using conventional design documents and minimized rules, leveraging assembly data and ladder programs to construct cause-and-effect relationships without relying on pre-existing failure data, by extracting key components and variables from these documents.

Benefits of technology

Facilitates rapid and cost-effective fault tree creation, reducing design periods, minimizing design costs, and enhancing maintainability by optimizing built-in alarm functions, thereby reducing downtime and improving support efficiency.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure 2024169347000001_ABST
    Figure 2024169347000001_ABST
Patent Text Reader

Abstract

To efficiently and automatically generate a fault tree.SOLUTION: A fault tree generation method includes the step of receiving assembly data and one or a plurality of ladder programs as input, and the method further includes: the step in which the assembly data includes a facility or line assembly tree and the one or the plurality of ladder programs include a facility or line control logic; and the step of generating a fault tree related to facility architecture based on an assembly tree structure included in the assembly data and the control logic included in the one or the plurality of ladder programs.SELECTED DRAWING: Figure 2
Need to check novelty before this filing date? Find Prior Art

Description

[Technical field]

[0001] The present disclosure relates to a system and method for automatic generation of fault trees. [Background technology]

[0002] It is necessary to maintain the uptime of a production line in order to maximize the productivity of a factory. One factor that reduces the uptime of a line is a machine failure due to some abnormal condition, and a quick recovery based on a root cause analysis of the machine failure is required. For this purpose, a fault tree analysis using a fault tree is generally performed. A fault tree is a tree diagram that includes a top node that indicates a failure event, a lower node that indicates a root cause phenomenon, and one or more branches that indicate a causal relationship of the phenomenon. When a fault is described in the fault tree, the root cause can be immediately identified, and it is an effective method that can prevent or eliminate the prolongation of downtime.

[0003] Fault trees are sometimes manually generated by equipment designers, since they require the architecture of the equipment to describe the causal relationships. If the equipment includes actuators and / or sensors, a general programmable logic controller can be used to control the equipment with a ladder program to achieve high reliability of operation. Since this type of equipment is designed not only by mechanical engineers but also by electrical engineers and control engineers, the fault trees are created by each of the different design teams. This collaborative work requires a huge amount of time, and the shortage of such experts has become more serious recently. To solve the above problems, several related technologies have been proposed.

[0004] In one example of related technology, a system is described that has a causal relationship database that stores equipment failure events and their causal relationships based on past failure events, and further has the names of component parts related to these causal relationships as indexes. In this system, by inputting the name of a component when constructing a fault tree, the related causal relationships are displayed, and the fault tree can be constructed efficiently.

[0005] In the above example, a fault tree can be constructed using information accumulated in the past. However, as a prerequisite, it is necessary to accumulate information on past failure events of similar products. Therefore, there is a problem that it cannot be applied to newly installed equipment or lines. Another problem is that it takes a lot of time to construct a causal relationship database. [Prior art documents] [Patent documents]

[0006] [Patent Document 1] JP 2017-194727 A Summary of the Invention

[0007] The present disclosure includes the automatic generation of fault trees.

[0008] The present disclosure proposes a system that automatically constructs a fault tree by using conventional design documents such as machine design drawings and control programs, and minimized rules or databases that can be generated from the design documents, without using prepared information such as cause information that does not yet exist in a newly designed facility or line.

[0009] To address the problems in the related art, the embodiments described herein include the following aspects.

[0010] The described embodiments include a novel technique for automatically generating a fault tree. The fault tree generation system receives as input assembly data including an equipment or line assembly tree and a ladder program including equipment or line control logic, and generates a fault tree by connecting a top portion of the fault tree generated from the assembly tree structure in the assembly data and a bottom portion of the fault tree obtained from the control logic in the ladder program.

[0011] In an embodiment including a fault tree generation system, the system generates a fault tree by connecting the upper part of the fault tree and the lower part of the fault tree based on the number of words in the full path of the upper part of the fault tree and the top word of the path in the lower part of the fault tree.

[0012] In one embodiment of the fault tree generation system, when generating the upper part of the fault tree, the system extracts major components from the assembly tree included in the assembly data using a parts name database that indicates each actuator, each sensor, component, etc. in addition to the assembly structure.

[0013] In an embodiment including a fault tree generation system, the system uses a read-write variable name database for each actuator, each sensor, component, etc. to extract key variables from the control logic when generating the sub-portions of the fault tree, and extracts the tree structure by converting the ladders associated with the key variables.

[0014] In an embodiment including a fault tree generation system, the part name database and variable name database of the fault tree generation system can have part names and variable names, respectively, grouped into common groups, and connections in both trees are made within the common groupings.

[0015] One aspect of the disclosure is a method that includes receiving as input assembly data and one or more ladder programs, where the assembly data includes a facility or line assembly tree and the one or more ladder programs include facility or line control logic, the method includes generating a fault tree associated with the facility architecture based on an assembly tree structure configured in the assembly data and the control logic configured in the one or more ladder programs.

[0016] One aspect of the disclosure is a computer program product for causing a computer to execute a process that receives as input assembly data and one or more ladder programs, the assembly data including an assembly tree for a facility or line, and the one or more ladder programs including facility or line control logic, and the process generates a fault tree associated with the facility architecture based on an assembly tree structure configured in the assembly data and the control logic configured in the one or more ladder programs.

[0017] One aspect of the present disclosure is a system including means for receiving as input assembly data and one or more ladder programs, the assembly data including an equipment or line assembly tree and the one or more ladder programs including equipment or line control logic, the system further including means for generating a fault tree associated with the equipment architecture based on an assembly tree structure configured in the assembly data and the control logic configured in the one or more ladder programs.

[0018] One aspect of the present disclosure is an apparatus for facilitating automatic generation of a fault tree, the apparatus including a processor receiving as input assembly data and one or more ladder programs, the assembly data including an equipment or line assembly tree, the one or more ladder programs including equipment or line control logic, and the processor generating a fault tree associated with an equipment architecture based on an assembly tree structure configured in the assembly data and the control logic configured in the one or more ladder programs. [Brief description of the drawings]

[0019] [Figure 1] FIG. 1 illustrates an example of an architecture for an automatic fault tree generation system. [Diagram 2] FIG. 1 illustrates an example block diagram of an automatic fault tree generation system. [Diagram 3] 1A to 1C are diagrams for explaining an example of parts and products assembled by the example apparatus. [Figure 4] FIG. 1 is a diagram for explaining an example of an overview of a device, the movement of parts, and related sensors. [Diagram 5] FIG. 2 illustrates an example process flow chart for an example apparatus. [Figure 6] FIG. 13 is a diagram showing an example of assembly data and related input / output variables in a ladder program. [Figure 7] FIG. 2 is a diagram for explaining an example of a ladder program. [Figure 8] FIG. 2 is a diagram for explaining an example of a ladder program. [Figure 9] FIG. 2 is a diagram for explaining an example of a ladder program. [Figure 10] FIG. 2 is a diagram for explaining an example of a ladder program. [Figure 11] FIG. 1 illustrates an example of a flowchart of an automatic fault tree generation system. [Figure 12] FIG. 12 is a diagram showing an example of a processing result of the flowchart in FIG. [Figure 13] 12 is a diagram for explaining an example of a processing result of the flowchart in FIG. 11. [Figure 14] 12 is a diagram for explaining an example of a processing result of the flowchart in FIG. 11. [Figure 15] 12 is a diagram for explaining an example of a processing result of the flowchart in FIG. 11. [Figure 16] 12 is a diagram for explaining an example of a processing result of the flowchart in FIG. 11. [Figure 17] 12 is a diagram for explaining an example of a processing result of the flowchart in FIG. 11. [Figure 18] 12 is a diagram for explaining an example of a processing result of the flowchart in FIG. 11. [Figure 19] 12 is a diagram for explaining an example of a processing result of the flowchart in FIG. 11. [Figure 20] 12 is a diagram for explaining an example of a processing result of the flowchart in FIG. 11. [Figure 21] FIG. 11 is a diagram for explaining an example of matching accuracy. [Figure 22] 12 is a diagram for explaining an example of a processing result of the flowchart in FIG. 11. [Figure 23] FIG. 1 is a diagram for explaining an example of a flowchart of an automatic fault tree generation system. [Figure 24] FIG. 11 is a diagram for explaining an example of assembly data. [Diagram 25] FIG. 11 is a diagram for explaining an example of assembly data. [Figure 26] FIG. 1 illustrates an example architecture of an automatic fault tree generation system. [Figure 27] FIG. 1 is a block diagram illustrating an example of an automatic fault tree generation system. [Figure 28] FIG. 1 is a diagram illustrating an example of a flowchart of an automatic fault tree generation system. [Figure 29] FIG. 11 is a diagram for explaining an example of a grouped node name database; [Diagram 30] FIG. 24 is a diagram showing an example of a processing result of the flowchart in FIG. 23. [Diagram 31] FIG. 11 is a diagram illustrating an example of a grouped node name database. [Diagram 32] FIG. 24 is a diagram for explaining an example of a processing result of the flowchart in FIG. 23. [Diagram 33] FIG. 24 is a diagram for explaining an example of a processing result of the flowchart in FIG. 23. [Diagram 34] FIG. 24 is a diagram for explaining an example of a processing result of the flowchart in FIG. 23. [Diagram 35] FIG. 11 is a diagram for explaining an example of matching accuracy. [Diagram 36] FIG. 11 is a diagram illustrating an example of matching accuracy. [Figure 37] FIG. 1 illustrates an exemplary computing environment including an exemplary computing device suitable for use in some exemplary embodiments. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0020] The following detailed description provides details of the figures and embodiments of the present application. Reference numbers between figures and redundant element descriptions are omitted for clarity. Terms used throughout this specification are provided by way of example and are not intended to be limiting. For example, the use of the term "automatic" can include fully automatic or semi-automatic embodiments with user or administrator control over certain aspects of the embodiment, depending on the desired embodiment of the person skilled in the art practicing the embodiments of the present invention. Selection can be performed by a user through a user interface or other input means, or can be performed through a desired algorithm. The embodiments described herein can be utilized singularly or in combination, and the functions of the embodiments can be performed through any means according to the desired embodiment.

[0021] The present application will be described in detail with three examples. In the first example, an overview of the system can be described, for example, as shown in Figures 1 and 2. In the second example, an example of equipment, for example, as shown in Figures 3 to 10, will be described. Figures 3 to 10 include an assembly tree and a ladder program. In the third example, a flowchart and a process flow will be described using the equipment data example in Figures 12 to 22.

[0022] 1 illustrates an example of a system architecture for an automatic fault tree generation system 100. The automatic fault tree generation system includes a processor that executes one or more modules associated with the automatic fault tree generation system. The modules may include, for example, but are not limited to, an assembly data analysis module, a ladder data analysis module, or a fault tree connection module. The processor may communicate with input modules, output devices, or memory / storage that may store analysis rules.

[0023] An example of a block diagram of the system is shown in Fig. 2. As shown in Fig. 2, the system input may include assembly data, such as CAD data, and ladder programs. An assembly data analysis module 206 may receive input from an assembly data input module 202 and corresponding analysis rules 204.

[0024] The ladder data analysis module 212 can receive inputs from the ladder data input module 208 and corresponding analysis rules 210. The fault tree connection module 214 can analyze and convert both input data from the assembly data analysis module and the ladder analysis module into a tree diagram with nodes and branches. After each conversion, it connects both modules into one tree in a connection module and builds the final fault tree as the output of the system. The fault tree output module 216 can receive inputs from the fault tree connection module in the tree generation.

[0025] Figure 3 shows an example of parts and products that may be assembled by the equipment. For example, part A 301 and part B 302 may be parts of an assembled product 303. In the example of Figure 3, part A and part B may be joined or connected to assemble the product. Figure 4 shows an overview 400 of the equipment movements, part movements, and associated sensors. Figure 4 shows an example of the movement process of part A 301 and part B 302 to assemble the product 303.

[0026] FIG. 5 shows a diagram 500 of a process flow chart of an example facility. One function of the facility is to insert part B into part A to assemble a product. The part movement process shown in FIG. 4 may include a conveying process and a transporting process for inserting or connecting part B to part A. Such conveying and transporting processes may include a conveyor and / or one or more motors for the inserting process, a clamper for clamping part B, and an air cylinder for transporting part B for the inserting process. Laser sensors may be used to detect the movement of each part and facility and / or to ensure proper assembly. An example of a process includes placing part A and part B in their respective part entrance areas. Part A is then transported to the inserting area and part B is transported to the waiting area. The conveying process may stop when part A or part B reaches its respective designated area, e.g., the inserting area. The clamper may then place part B in the waiting area. The clamper may then pick up part B and move part B to the inserting area of ​​part A. The clamper may insert part B into part A, and part B may be released upon insertion of part B into part A. The assembled product is then transported to an ejection area.

[0027] FIG. 6 shows a diagram 600 of an assembly tree that may be included in CAD data and associated input / output variables in a ladder program. The assembly tree may include both assemblies and parts, and the assembly tree is generated by a designer. The automated equipment includes user interfaces such as push buttons and safety components such as light curtains and emergency stop (E-stop) buttons. The components such as drive units and sensing units may be electrically connected to a controller. The controller may be a programmable logic controller (PLC), and a programming language (e.g., a ladder program) may utilize the variables shown in FIG. 6, for example.

[0028] FIG. 7 is an example of a ladder program 700. Ladder programs can document the design and construction of relay racks used in manufacturing and process control. The name comes from the fact that programs in this language resemble a ladder, with two vertical rails and a series of horizontal rungs in between. Signals come in from the + voltage side and go to the ground side. Once the logic is clear, variables can be changed. The program starts at the top rung and repeats as necessary until the bottom rung is reached.

[0029] Figures 8-10 show examples of ladder programs that can be used to implement the process flow in the present equipment as shown in relation to Figures 4 and 5. Rungs R1-17 may contain variably defined regions for inputs and outputs, runs R18-20 may contain control logic for both conveyors, runs R21-26 may contain control logic for transporting part B, and runs R27-30 may contain control logic for the insertion process.

[0030] FIG. 11 shows an example flowchart 1100 of an automatic fault tree generation system. The input data of A-1 is shown, for example, in FIG. 6, and the input data of B1 is shown, for example, in FIGS. 8-10. In A-2, an assembly tree is extracted from A-1. In A-3, the main layers of the assembly tree, excluding parts, are extracted. In A-4, a message related to the error (e.g., "is not correctly working") is added to each tree node. In A-5, a supertree of the fault tree is generated.

[0031] At B-2, the primary variables representing the moves are identified. At B-3, rungs associated with the primary variables of the moves are extracted from the input ladder program. At B-4, each tree node is converted into a tree with a status message (e.g., "is on" or "is off"). At B-5, subtrees of the fault tree are generated.

[0032] In C-1, the generated upper tree and lower tree are obtained. In C-2, at least one full path from the bottom node to the top node of the upper tree is selected, and all words in the picked full path are extracted as word group A. In C-3, a top node is selected from one of the lower trees, and all words in the node are extracted as word group B. In C-4, the amount of matching words between word group A and word group B is calculated. In C-5, the processes of C2 to C4 are repeated, and all combinations are counted, and the count number can be treated as the degree of matching. In C-6, the connection between the upper tree bottom node and the lower tree top node is determined based on at least the order of the degree of matching. In C-7, each lower tree is connected to each upper tree node so that the outputted connected tree constitutes a fault tree.

[0033] FIG. 12 is a diagram showing the processing result from A-4 onward in FIG. 11, and represents the upper part of a fault tree based on the facility structure. The fault tree may include at least one of a node, a branch, and a logic gate. A fault phenomenon or its cause is input to a node, and each related node is connected by a line called a branch. With this connection, the upper node is called a parent node of the lower node, and the lower node is called a child node of the upper node. FIG. 12 shows examples of nodes, branches, and logic gates that may be used. However, the present disclosure is not intended to be limited to the examples disclosed herein. In some examples, different combinations or numbers of nodes, branches, or logic gates may be used.

[0034] FIG. 13 shows a partial processing result after B-3 in FIG. 11. For example, rungs R18-R20 can constitute the rungs used in the partial processing result after B-3 in FIG. 11. FIG. 14 shows a partial processing result after B-4 as an example of a processing procedure. In B-2, a main variable may be selected based on some rule. In this equipment example, since the word "Request" is used to command a movement, "Request" is searched for among all variables in the ladder program to select a main variable. As described in FIG. 7, the ladder program may be converted into a tree diagram as shown in FIG. 14. In some embodiments, True and False may be converted into the words "is on" or "is off". FIG. 15 shows an example of a processing result after B-4 in FIG. 11. The trees in FIG. 14 and FIG. 15 may include a subpart of a fault tree.

[0035] The partial fault trees are generated up to A-4 and B-4 processes, transferred to the connection module in A-5 and B-5 processes, and retrieved for connection in C-1 process. The connection procedure starts from C-2 process and runs up to word matching calculation, connecting the upper and lower parts of the fault tree to generate a complete fault tree. The word matching calculation can utilize the source word group and the target word group.

[0036] FIG. 16 shows an example 1600 of a word group extracted from a top tree that can be used as a source word group, and FIG. 17 shows an example 1700 of a word group extracted from a bottom tree that can be used as a target word group. At least one advantage of the present disclosure is to utilize full path words instead of bottom nodes of the top tree because the bottom nodes of the top tree may not contain all words that describe the assigned function. The reason is that the top tree is a tree diagram generated so that node names are not duplicated. In some aspects, the bottom tree is generated from program variables, and these variables have unique names throughout the program. Utilizing full paths in the top tree can be beneficial and enable accurate matching.

[0037] The rule of the matching count is "How many FPX words existing TNY," which means C-4 in Figure 11, and the calculation result 1800 is shown in Figure 18. To determine the connection node, a deviation calculation 1900 is calculated, which represents the difference from the average value, as shown in Figure 19.

[0038] An example of the judgment rule is as follows:

[0039] Select the item with the highest standard deviation in the @1.TNX row.

[0040] @2. If the parent node and child node have the same score, select the child node.

[0041] FIG. 20 shows an example of selected connections 2000 in bold. For example, TN1 and FP3 provide a connection, TN2 and FP4 provide a connection, TN3 and FP7 provide a connection, TN4 and FP7 provide a connection, TN5 and FP7 provide a connection, TN6 and FP6 provide a connection, and TN7 and FP6 provide a connection. FIG. 21 shows an example of matching accuracy 2100, showing that all connections are correctly matched. FIG. 22 shows an example of the final fault tree 2200, which may be an output from the flowchart in FIG.

[0042] FIG. 23 shows an example flowchart 2300 of an automatic fault tree generation system. The flowchart of FIG. 23 is similar to the flowchart of the automatic fault tree generation system of FIG. 11, but there are some differences. For example, the differences between the flowchart of FIG. 11 and the flowchart of FIG. 23 are steps A-1 and A-2.5 of FIG. 23. The input data included in step A-1 may include not only CAD data 2400 shown in FIG. 24 but also bill of material (BOM) data 2500, for example, as shown in FIG. 25. In some examples, drawing number names are used in CAD data to describe an assembly tree, and BOM data can be used for conversion from drawing numbers to assembly or part names. With this conversion, the same calculation as the example flowchart of FIG. 11 can be established even if the assembly data is separated into CAD data and BOM data. In this way, the flowchart of FIG. 23 can generate upper and lower trees of a fault tree, similar to the example of FIG. 11.

[0043] FIG. 26 provides an example architecture of an automatic fault tree generation system 2600. The example architecture of the automatic fault tree generation system of FIG. 26 can have similar components and functions as the example architecture of the automatic fault tree generation system of FIG. 1, except that the analysis rules are replaced by a database. FIG. 27 shows an example of a system block diagram 2700. The block diagram shown in FIG. 27 is similar to the block diagram of the system shown in FIG. 2, but there are some differences. For example, the difference from the block diagram of FIG. 2 is that some databases are used in the analysis module, whereas in the block diagram of FIG. 27, some groups defined in the database are used in the connection process, and the output of the assembly data analysis module 206 is based on the input from the assembly data input module 202 and the input from the node name grouping database 2702. Furthermore, the output from the ladder data analysis module 212 is based on the input from the ladder data input module 208 and the input from the variable name grouping database 2704.

[0044] FIG. 28 illustrates an example flowchart 2800 of an automatic fault tree generation system, and FIG. 29 illustrates an example 2900 of a node name grouping database 2702. The example flowchart of FIG. 28 is configured similarly to the flowchart of FIG. 11, but includes an additional step, namely, A-3.5. In A-3.5, nodes can be extracted by searching the grouped node name database. The illustrated grouped node name database is used in A-3.5 of FIG. 28 to search for nodes and extract important nodes, such as drive units and measurement units, from the assembly tree.

[0045] Fig. 30 shows an example 3000 of the processing result after the A-3.5 process of Fig. 28. Based on the database usage, detailed key components such as motors and laser sensors that may be the root cause of the failure can be extracted.

[0046] FIG. 31 shows an example 3100 of the variable name grouping database 2704 that may be used in B-2 of the processing example of FIG. 28. The variables in the program include name variables that may indicate a unique name and / or an expression. In some embodiments, the variables may include abbreviated names such as, but not limited to, LS (laser sensor), LC (light curtain), PB (push button), etc. The variable database can correctly extract key variables related to key logic. FIG. 32 shows the processing result after B-4 of FIG. 28, where multiple sub-fault trees can be extracted using the variable names.

[0047] Fig. 33 shows an example 3300 of a word group extracted from an upper tree as a source word group, and Fig. 34 shows an example 3400 of a word group extracted from a lower tree as a target word group. At least one other difference from the conventional example is that a group including both Fig. 33 and Fig. 34 is used for connection processing. In order to reduce matching errors due to an increase in combinations, matching calculation is performed using an internal group.

[0048] FIG. 35 shows an example 3500 calculated without group information, and FIG. 36 shows an example 3600 calculated with group information. After calculations on the inner groups, the results are combined. Comparing FIG. 35 and FIG. 36, it can be seen that the presence of group information improves the matching accuracy. Also, the calculation time is reduced by performing the calculations separately.

[0049] The disclosed system can be configured to generate a fault tree using design documents and minimized rules or databases. By utilizing this system, it is possible to shorten the design period and reduce design costs related to maintainability design, and to reduce on-site problems after shipment by optimizing built-in alarm functions before shipping equipment or production lines. It also improves the ease of designing new architecture equipment and lines, expanding and increasing the business of equipment builders and line builders. By utilizing the generated fault tree, it is possible to realize technology transfer between design teams and support teams and improve support efficiency. By utilizing the generated fault tree, it is possible to reduce oversights in root cause analysis, quickly identify root causes, and reduce contact time with vendor support, thereby minimizing downtime for equipment customers.

[0050] FIG. 37 illustrates an example computing environment with a computing device suitable for use in the embodiments, such as those illustrated in connection with any of FIGS. 1-36. The computing environment can be used to facilitate implementation of the architecture illustrated in FIGS. 1-36. Additionally, any of the embodiments described herein can be implemented based on the architectures, APIs, microservices systems, etc. illustrated in FIGS. 1-36. The computing device 3705 of the computing environment 3700 can include one or more processing units, cores, or processors 3710, memory 3715 (e.g., RAM, ROM, and / or the like), internal storage 3720 (e.g., magnetic, optical, solid-state storage, and / or organic), and / or I / O interface 3725, any of which can be coupled with a communication mechanism or bus 3730 for communicating information or embedded in the computing device 3705. The I / O interface 3725 is configured to receive images from a camera or provide images to a projector or display device, depending on the desired implementation.

[0051] The computing device 3705 may be communicatively coupled to an input / user interface 3735 and an output device / interface 3740. Either or both of the input / user interface 3735 and the output device / interface 3740 may be wired or wireless interfaces and may be removable. The input / user interface 3735 may include any device, component, sensor, or interface, physical or virtual, that may be used to provide input (e.g., buttons, touch screen interfaces, keyboards, pointing / cursor controllers, microphones, cameras, Braille, motion sensors, optical readers, and / or the like). The output device / interface 3740 may include displays, televisions, monitors, printers, speakers, Braille, etc. In some embodiments, the input / user interface 3735 and the output device / interface 3740 may be embedded in the computing device 3705 or physically coupled to the computing device 3705. In other embodiments, other computing devices may function as or provide the functionality of the input / user interface 3735 and output device / interface 3740 of the computing device 3705.

[0052] Examples of computing devices 3705 may include, but are not limited to, highly mobile devices (e.g., smart phones, devices mounted on vehicles and other machines, devices carried by humans and animals, etc.), mobile devices (e.g., tablets, notebook computers, laptop computers, personal computers, portable televisions, radios, etc.), and devices not designed for mobility (e.g., desktop computers, other computers, information kiosks, televisions, radios having one or more processors embedded therein and / or coupled thereto, etc.).

[0053] Computing device 3705 may be communicatively coupled (e.g., via I / O interface 3725) to external storage 3745 and a network 3750 for communicating with any number of networked components, devices, and systems, including one or more computing devices of the same or different configurations. Computing device 3705, or any connected computing device, may function, provide a service, or be referred to as a server, a client, a thin server, a general machine, a special purpose machine, or by other labels.

[0054] I / O interface 3725 can include, but is not limited to, wired and / or wireless interfaces using any communication or I / O protocol or standard (e.g., Ethernet, 802.11x, Universal System Bus, WiMax, modem, cellular network protocols, etc.) for communicating information to and from at least all connected components, devices, and networks in computing environment 3700. Network 3750 can be any network or combination of networks (e.g., the Internet, a local area network, a wide area network, a telephone network, a cellular network, a satellite network, etc.).

[0055] The computing device 3705 may use and / or communicate using computer usable or computer readable media, including transitory and non-transitory media. Transitory media include transmission media (e.g., metallic cables, optical fibers), signals, carrier waves, etc. Non-transitory media include magnetic media (disks, tapes, etc.), optical media (CD ROM, digital video disks, Blu-ray disks, etc.), solid-state media (RAM, ROM, flash memory, solid-state storage, etc.), and other non-volatile storage or memory.

[0056] The computing device 3705 can be used to implement techniques, methods, applications, processes, or computer-executable instructions in some exemplary computing environments. The computer-executable instructions can be obtained from a transient medium and can be stored on and obtained from a non-transient medium. The executable instructions can be obtained from one or more of a programming language, a scripting language, and a machine language (e.g., C, C++, C#, Java, Visual Basic, Python, Perl, JavaScript, etc.).

[0057] The processor 3710 can run under any operating system (OS) in a native or virtual environment. One or more applications can be deployed, including a logic unit 3760, an application programming interface (API) unit 3765, an input unit 3770, an output unit 3775, and an inter-unit communication mechanism 3795 for different units to communicate with each other, the OS, and other applications. The described units and elements may vary in design, function, configuration, or implementation, and are not limited to the configuration provided herein. The processor 3710 can be in the form of a hardware processor, such as a central processing unit (CPU), or a combination of hardware and software units.

[0058] In some embodiments, when information or instructions to execute are received by API unit 3765, it may be communicated to one or more other units (e.g., logic unit 3760, input unit 3770, output unit 3775). In some embodiments, logic unit 3760 may be configured to control the flow of information between units and direct the services provided by API unit 3765, input unit 3770, output unit 3775 in some embodiments described above. For example, the flow of one or more processes or implementations may be controlled by logic unit 3760 alone or in conjunction with API unit 3765. Input unit 3770 may be configured to obtain inputs for calculations described in the embodiments, and output unit 3775 may be configured to provide outputs based on the calculations described in the embodiments.

[0059] 1-36 , the instructions may include receiving as input assembly data and one or more ladder programs, where the assembly data includes an assembly tree for a piece of equipment or a line, and the one or more ladder programs include control logic for the equipment or line. The processor 3710 generates a fault tree associated with the equipment architecture based on the assembly tree structure included in the assembly data and the control logic included in the one or more ladder programs.

[0060] The processor 3710 may be configured to execute instructions of a method, for example, in any of Figures 1 to 36, that connects an upper portion of a first fault tree based on an assembly tree structure contained in assembly data with a lower portion of a second fault tree based on control logic contained in one or more ladder programs.

[0061] The processor 3710 may be configured to execute instructions of a method that includes extracting one or more components of an equipment architecture from an equipment or line assembly tree in the assembly data based on a part name database that identifies each of one or more components from a top portion of a first fault tree, for example in any of FIGS. 1-36.

[0062] The processor 3710 can be configured to execute instructions of a method that includes, for example, in any of Figures 1 to 36, extracting one or more variables from the equipment or line control logic based on a variable name database of one or more components of the equipment architecture, and extracting an assembly tree structure based on a ladder program associated with the one or more variables.

[0063] Some portions of the detailed description are presented in terms of algorithms and symbolic representations of operations within a computer. These algorithmic descriptions and symbolic representations are the means used by those skilled in the data processing arts to convey the substance of their innovations to others skilled in the art. An algorithm is a sequence of defined steps leading to a desired end state or result. In the illustrative examples, the steps performed require specific quantities of physical manipulations to achieve a specific result.

[0064] Unless otherwise indicated, as will be apparent from the discussion herein, discussions throughout this specification using terms such as "processing," "computing," "calculating," "determining," "displaying," and the like may include operations and processes of a computing system or other information processing device that manipulate and transform data represented as physical (electrical) quantities in the registers and memory of the computing system into other data similarly represented as physical quantities in the memory, registers, or other information storage, or transmission or display device of the computing system.

[0065] The embodiments also relate to an apparatus for performing the operations herein. The apparatus may be specially constructed for the required purposes, or may include one or more general-purpose computers selectively activated or reconfigured by one or more computer programs. Such computer programs may be stored on a computer-readable medium, such as a computer-readable storage medium or a computer-readable signal medium. Computer-readable storage media include, but are not limited to, tangible media such as optical disks, magnetic disks, read-only memories, random access memories, solid-state devices and drives, and other types of tangible or non-transitory media suitable for storing electronic information. Computer-readable signal media may include media such as carrier waves. The algorithms and displays presented herein are not inherently related to any particular computer or other apparatus. A computer program may include a pure software implementation that includes instructions for performing the operations of a desired implementation.

[0066] Various general-purpose systems may be used with the programs and modules according to the embodiments herein, or more specialized apparatus may be constructed to perform the desired method steps. Moreover, the embodiments are not described with reference to a particular programming language. Various programming languages ​​may be used to implement the techniques of the embodiments described herein. Instructions in the programming language may be executed by one or more processing devices, such as a central processing unit (CPU), processor, or controller.

[0067] As known in the art, the operations described above may be performed by hardware, software, or some combination of software and hardware. Various aspects of the embodiments may be implemented using circuits and logic devices (hardware), while other aspects may be implemented using instructions stored on a computer-readable medium (software) that, when executed by a processor, cause the processor to perform the implementation of the present application. Furthermore, some embodiments of the present application may be performed exclusively in hardware, while other embodiments may be performed exclusively in software. Furthermore, the various functions described may be performed in a single unit or may span multiple components in any manner. When performed by software, the method may be executed by a processor, such as a general-purpose computer, based on instructions stored on a computer-readable medium. If desired, the instructions may be stored on the medium in a compressed and / or encrypted format.

[0068] Moreover, other embodiments of the present invention will be apparent to those skilled in the art from consideration of the specification and practice of the techniques of the present invention. Various aspects and / or components of the described embodiments may be used alone or in any combination. It is intended that the specification and examples be considered as exemplary only, with a true scope and spirit of the present application being indicated by the following claims. [Explanation of symbols]

[0069] 100 Automatic Fault Tree Generation System 206 Assembly Data Analysis Module 202 Assembly Data Input Module 204 Analysis Rules 212 Ladder Data Analysis Module 208 Ladder Data Input Module 210 Analysis Rules 214 Fault Tree Connection Module 2702 Node Name Grouping Database 2704 Variable Name Grouping Database

Claims

1. receiving as input assembly data and one or more ladder programs, the assembly data including a facility or line assembly tree and the one or more ladder programs including a facility or line control logic; generating a fault tree associated with an equipment architecture based on an assembly tree structure contained in the assembly data and control logic contained in the one or more ladder programs.

2. 2. The method of claim 1 , The step of generating a fault tree associated with the facility architecture further comprises: The method includes a step of connecting an upper portion of a first fault tree based on an assembly tree structure included in the assembly data and a lower portion of a second fault tree based on control logic included in the one or more ladder programs.

3. 3. The method of claim 2, A method in which the step of connecting an upper portion of the first fault tree based on the assembly tree structure and a lower portion of the second fault tree based on the control logic is based on the amount of words contained in a full path of the upper portion of the first fault tree and the top words of a path of the lower portion of the second fault tree.

4. 3. The method of claim 2, The method further includes extracting one or more components of the facility architecture from a facility or line assembly tree in the assembly data based on a part name database that identifies each of the one or more components from a top portion of the first fault tree.

5. 2. The method of claim 1 , Generating a fault tree associated with the facility architecture includes: extracting one or more variables from the facility or line control logic based on a variable name database of one or more components of the facility architecture; extracting the assembly tree structure based on a ladder program associated with the one or more variables.

6. 3. The method of claim 2, the fault tree part name database and variable name database include part names or variable names grouped into one or more common groups; The connection of the first fault tree and the second fault tree is based on a grouping of the one or more common groups.

7. 2. The method of claim 1, The equipment or line assembly tree includes associated input and output variables in the one or more ladder programs.

8. 2. The method of claim 1 , The method of claim 1, wherein a fault tree associated with the facility architecture includes one or more nodes, one or more branches, and one or more logic gates.

9. 9. The method of claim 8, the one or more nodes contain information related to a failure event; A method according to claim 1, wherein each of said one or more nodes is connected to a respective branch of said one or more branches.

10. 9. The method of claim 8, The one or more logic gates are connected between an upper portion of a first fault tree and a lower portion of a second fault tree.

11. A non-transitory computer readable medium storing instructions for causing one or more processors to perform a process, the process comprising: receiving as input assembly data and one or more ladder programs, the assembly data including a facility or line assembly tree and the one or more ladder programs including a facility or line control logic; generating a fault tree associated with an equipment architecture based on an assembly tree structure included in the assembly data and control logic included in the one or more ladder programs.

12. 12. The non-transitory computer readable medium of claim 11, A non-transitory computer-readable medium, the process including a step of connecting an upper portion of a first fault tree based on an assembly tree structure included in the assembly data and a lower portion of a second fault tree based on control logic included in the one or more ladder programs.

13. 13. The non-transitory computer readable medium of claim 12, A non-transitory computer-readable medium, wherein the step of connecting an upper portion of the first fault tree based on the assembly tree structure and a lower portion of the second fault tree based on the control logic is based on the amount of words contained in a full path of the upper portion of the first fault tree and the top words of a path of the lower portion of the second fault tree.

14. 13. The non-transitory computer readable medium of claim 12, The process further includes extracting one or more components of the facility architecture from an equipment or line assembly tree in the assembly data based on a part name database that identifies each of the one or more components from a top of the first fault tree.

15. 12. The non-transitory computer readable medium of claim 11, The process comprises: extracting one or more variables from the facility or line control logic based on a variable name database of one or more components of the facility architecture; and extracting the assembly tree structure based on a ladder program associated with the one or more variables.

16. 13. The non-transitory computer readable medium of claim 12, the fault tree part name database and variable name database include part names or variable names grouped into one or more common groups; A non-transitory computer-readable medium, wherein the connection of the first fault tree and the second fault tree is based on a grouping of the one or more common groups.

17. 12. The non-transitory computer readable medium of claim 11, A non-transitory computer readable medium, the equipment or line assembly tree including associated input and output variables in the one or more ladder programs.

18. 12. The non-transitory computer readable medium of claim 11, a fault tree associated with the facility architecture including one or more nodes, one or more branches, and one or more logic gates; the one or more nodes contain information related to a failure event; each of the one or more nodes is connected to a respective branch of the one or more branches; The one or more logic gates are connected between an upper portion of a first fault tree and a lower portion of a second fault tree.

19. 1. A system comprising: A facility architecture based on an assembly tree structure; a processor; The processor, receiving as input assembly data and one or more ladder programs, the assembly data including a facility or line assembly tree and the one or more ladder programs including facility or line control logic; The system generates a fault tree associated with the equipment architecture based on an assembly tree structure contained in the assembly data and control logic contained in the one or more ladder programs.

20. 20. The system of claim 19, The system, wherein the processor connects an upper portion of a first fault tree based on an assembly tree structure contained in the assembly data and a lower portion of a second fault tree based on control logic contained in the one or more ladder programs.

Citation Information

Patent Citations

  • Information processing device, information processing method and information processing program

    JP2022137914A

  • Computer-implemented method for generating a mixed-layer fault tree of a multi-component system combining different layers of abstraction

    US20220058323A1

  • Causal relation extraction device, causal relation extraction method and causal relation extraction program

    JP2017194727A