JPH04335443A - Method and apparatus for isolating defective part in system - Google Patents

Abstract

PURPOSE: To provide a method for isolating the defective component in the system consisting of plural components which generates error codes when an expected state is generated as to at least a small number of components. CONSTITUTION: This method includes a process for the confirmation 202 of error codes generated by arbitrary components of the system, a process for the confirmation 206 of which component has generated the error codes, a process for the confirmation 208 of loops or strings including the components having generated the error codes, a process for the determination 210 of a test to be conducted for a suspicious component consisting at least part of the confirmed loops or strings by regarding the respective components constituting the loops or strings as suspicious components, a process for the execution 212 of the confirmed test, a process for the confirmation 218 of another test to be conducted by excluding all components of the loops or strings that the operation has inspected as suspicious components when no defective component is confirmed 214, and a process for repairing or replacing a defective component when the defective component is confirmed 222.

Description

[Detailed description of the invention]

0001

[Relationship with related applications] This application has a pending U.S. patent application serial number (applicant copy number RD-19,996).
, RD-19,994, RD-19,997, and RD
-19,995).

0002

BACKGROUND OF THE INVENTION This invention relates to fault isolation methods and, more particularly, to methods that can be used as part of a fault isolation method to facilitate faster, more accurate isolation of faults.

Fault isolation typically refers to the process of identifying defective components within a system. Typically, engineers
Isolation is usually accomplished with the help of automated equipment. Specifically, when a mechanical problem is detected, a customer typically contacts a service station, and the service station dispatches a technician to the customer's location. . Engineers then perform a series of tests in an attempt to isolate the fault. The test order and the parts actually tested are usually determined by the engineer. Therefore, the length of time required to isolate a fault as well as the accuracy of fault isolation are highly dependent on the experience and skill of the technician and the complexity of the machine.

[0004] In large, complex systems, the components that make up the system typically have their own electronic sensors and their own error detection devices. Each error detection device issues an error code when each sensor detects an abnormality.
generates a code. The error code is also referred to as a defective code, defective message, error message, etc. in this specification. Fault codes alert the operator to potentially faulty conditions within the system, e.g. Corresponds to "High". Typically, these error codes
Analyzing a list of codes, such as a printout or display, is typically the technician's starting point.

[0005] Isolating defective parts in complex systems made up of large numbers of parts, eg, thousands of parts, can be a very time consuming and difficult problem. In an attempt to reduce the amount of time required to isolate a fault, expert systems have been used in the fault isolation process. Generally, the effectiveness with which an expert system can isolate a fault improves as the number of symptoms or initial data available regarding the problem increases. However, as the number of symptoms for a particular malfunction becomes large, or as side-effects of the actual problem introduce derivative information, the information must be discerned before analysis can occur. Even after this discerning filtering action, many error codes may remain. Given the large number of possible error codes, modeling the rules and logical connections within an expert system is an astronomical challenge. Even if it is possible to model the rules in an expert system, the response time of the expert system is too slow and the quality of diagnosis is poor as a result of the complexity involved in creating and processing the rule model. Sometimes it's not that high. Maintenance and future enhancement of such expert systems is also a problem.

Although automated methods are believed to be very helpful in fault isolation, although simple, accurate fault identification is not possible even under conditions where a large number of false messages/codes are generated. There is a demand for equipment that allows isolation.

Additionally, to reduce the amount of time it takes for a technician to isolate a fault, a list of error codes can be used to determine the tests that a technician should perform to isolate the fault. It is desirable to provide automated equipment that allows for confirmation. Preferably, the tests are verified before the technician arrives on-site so that, upon arrival, the technician can immediately begin testing operations to isolate the fault.

[0008]

SUMMARY OF THE INVENTION The fault isolation algorithm of this invention
This includes the step of confirming the code. This operation includes, for example, typically reading data from a field computer and storing the data in central computer memory. Once the error message/code is identified, the next step is to identify the component that generated the error message/code. A component error code correlation lookup table with all possible error messages/codes and their corresponding internal components can be used to determine which components are associated with each error message/code. - Check to see if a code has occurred.

Once it is known which component generated the error code, the next step is to identify the loop/string made up of the components that generated the error message/code. be. Preferably one loop/string is checked. This one loop/string consists of all the parts that generated the error message/code. However, it should be appreciated that in some fault isolation cases, several loops/strings may be identified. Lou
After confirming the loop/string, the previously confirmed loop/string
Determine the tests to perform on the parts that will exclude most of the parts in the string. Simply put, Lou
Parts that may be defective from the pull/string include:
By removing as many parts as possible, the time required to isolate the actual defective parts is reduced. This is assuming that each test takes approximately the same amount of time to perform. If there are differences in factors such as the length of time and cost required to perform each test, these factors can also be taken into account. Once a test is confirmed, the next confirmed test is conducted.

[0010] After performing the test, if no defective parts are found, the next step is to identify any parts that may still be defective. Particularly if the test just performed does not verify that all parts of the string/loop are working properly, parts that are still at risk of failure should be identified. For example, if a verified loop consists of parts B, D, E, F, G, H, and I, and the first test performed
, G, H, and I are verified to be operating correctly, parts B and F remain as potentially defective parts.

[0011] Next, a test that eliminates most of the parts as likely to be defective is confirmed, and the confirmed tests are carried out. For example, in the previous example, ideally a test would be performed next to verify the operation of parts B and F. However, although there is no such test, if there is a test to verify the operation of component B, that test is conducted, for example. If the defective part is still not identified, identify the potentially defective part and repeat the process. The above and other objects, as well as other features and advantages of the present invention will become apparent from the following detailed description of the drawings.

0012

DESCRIPTION OF THE PREFERRED EMBODIMENTS The present invention is preferably implemented by a computer. For example, the source code expressions of this invention may be input into a computer to control its operation. It is contemplated that the present invention can be implemented using a large number of source code expressions written in one of a number of computer languages, and it is difficult to determine which particular expression is used here. That's not to say it's preferable. A variety of computing systems can be used to implement the invention, including, for example, personal computers, work stations, and the like. However, the practice of this invention is not limited to any particular computer, and the selection of a particular computer may be made for various reasons.

More specifically with reference to the drawings, FIG. 1 shows an algorithm 100 for representing connectivity of parts. Specifically, implementing algorithm 100 provides a label scheme for assigning labels to parts of the system. This labeling system is expected to facilitate automation of the fault isolation process and provide a new way to display component connectivity.

[0014] In this labeling scheme, after the starting action indicated by departure 102, the next step 104 is to diagnose the device as consisting of a number of parts/parts, together with the physical and logical connections between them. To represent a machine or system in the form of a diagram. This step is typically performed by a system development engineer with the aid of a graphics editor comprised of a computer. If the system is relatively simple, it may not be necessary to physically generate such diagrams. Further details regarding the generation of such a display will be described later.

Briefly, after performing step 104,
A starting part, ie, a starting part/subsystem, is selected and the starting part is labeled "1" as shown in step 106. Then, as shown at 108, check the children of the part you just labeled (for the first iteration, they will be the children of the starting part), and assign alphanumeric characters starting with 1 to those children sequentially. Assign. Thereafter, as shown at 110, it is determined whether the parts that are children in at least some degree, such as grandchildren, great-grandchildren, etc., have been labeled as children. If these parts have not yet been so labeled, operation then returns to step 108. If all child parts have been labeled as child parts, operation then proceeds to step 112. Specifically, step 112 determines whether a part that is a child part of any other part has been labeled as such. If such a component is not labeled as a child component, operation then returns to step 108. If all child parts have been labeled as child parts, it is then determined, as shown in step 114, whether any of the parts are unlabeled. If a part is unlabeled, the unlabeled part is selected as the starting part and the new starting part is labeled (i+1), as shown in step 116. Operation then returns to step 108. Once all parts have been labeled, the operation ends, as indicated by end symbol 118.

To illustrate the level of detail that may be selected to represent the system as required in step 104, FIG. 2 depicts a system that includes two subsystems, subsystem A and subsystem B. There is. Note that some parts, such as part K, are included in both subsystem A and subsystem B representations. The level of detail for displaying components in each subsystem is typically selected by the design/development engineer. for example,
A resistance may be represented as a component of a subsystem, or the resistance may actually be a subcomponent of a larger component represented in the diagram. Each component of each subsystem is represented by a block of circles and is selected by alphanumeric characters. However, it should be appreciated that each circular block may represent an entire subsystem or may be subdivided into smaller representations.

For example, FIGS. 3A and 3B illustrate different levels of the system diagram relative to the diagram shown in FIG. More specifically, FIG. 3A is a higher level representation of the system shown in FIG. In FIG. 3A, the system has two subsystems, namely subsystems A and B.
It is shown as having . This is a relatively high level representation of the system. In contrast, FIG. 3B is a more detailed representation, ie, a lower level representation of part A of subsystem A of FIG. Of course, such low level details can be expressed for other parts as well. Figure 3
In the case shown in B, part A is composed of many subcomponents.

[0018] Although displaying components at a lower level may allow for more accurate isolation of failures, processing graphs with such lower level detail requires longer processing time. This is one point that is compatible. For example, from the diagram in FIG. 3B, it is possible to isolate if there is a failure in subcomponent A1221 of component A in subsystem A, but when using the diagram in FIG. If there is a failure, the only thing that can be done is to isolate it. The processing time required to isolate subcomponent A 1221 as faulty may be longer than the time required to determine that the fault is within subsystem A as a whole. The level of display to be used is determined on a case-by-case basis with these considerations in mind.

Another factor to consider when creating a diagram is determining which components generate each error code. Preferably, each component that generates an error code is represented as a single component in the diagram. If one component does not have the ability to generate at least one error code, for example a sensor and its associated error detection device, then that component can be represented as part of another component in the diagram. .

For example, assume that parts B and C are coupled in series in a large system of 50 parts. If both parts B and C have the ability to generate their respective error codes, parts B and C can be represented as independent parts in the diagram. Of course, parts B and C
A logical connector is provided between them. On the other hand, if only component B is capable of generating at least one error code, then for diagrammatic purposes, components B and C can be represented as one component. Of course, the usefulness of creating such a combination must be judged on a case-by-case basis. Of course, in some cases it may be desirable to represent a component as independent, even if that component does not generate an error code. For example, if the component has a high probability of failure, it may be desirable to represent the component as an independent component. For example, a cable that connects two parts is
If a bull has a high failure probability, it can be represented as an independent component with its own label.

FIG. 4 is a mid-level representation of the system, including parts designated as parts A-M. The algorithm 100 assigns a label to each component as follows.

[0022]
Table 1 Part A
1 112
121111 Part B 11
112111111
Part C 111
Part D 112
Part E 1121 Part F
11211 Parts G
112111 Parts H 11
21111 Part I 112
11111 Parts J 112
12 Parts K 112121
Part L 1121211
Part M 11212111 Specifically regarding Table 1, part A has been confirmed as the starting part (however, any other part may be selected),
Part A is assigned the label "1". Part B is a child of part A and is assigned the label "11" (as shown in step 108). Parts C and D are children of their respective parts B and are labeled "111" and "11" respectively.
2" is assigned. A label is created like this by tracking all the parts.

[0023] In addition to the label "1", part A has a label "1".
112121111" is also attached. This label represents the connection from part M to part A. Specifically, part A is a starting part, and part M
He is also the child of Similarly, part B is “112111111
” and this is part B.
indicates that it is a child of part I in addition to being a child of part A (as indicated by the label "11").

The component labeling scheme described above has the advantage that, in addition to generating a unique label for each component, it also indicates connectivity between components. Indication of connectivity, as will be discussed in more detail later, is important for isolating faults. Of course, the fault isolation described herein is not limited to being implemented using connectivity representations generated according to algorithm 100, although such connectivity representations are preferred.

The component connectivity representation generated according to algorithm 100 is stored in the memory of a computer system used to perform fault isolation. It is possible to automate the process of displaying the system to be monitored, that is, creating a connection diagram and assigning labels, but this process (
It is conceivable that the process be carried out by a human (for example with the aid of a computer) and then entered into the memory of the computer by a computer system development engineer. The labeling process shown in FIG. 1 is preferably performed off-line rather than at the time of fault isolation. Otherwise, the time required to perform the actual on-line fault isolation process is increased by the time required to create such diagrams and labels.

Further, prior to processing, it is preferred that the computer system development engineer store in the computer's memory predefined tests that can be performed on the various components of the system. Of course, the results of each test shall be verifiable. Along with each test, the component field corresponding to each test field indicates which components each test can be used to determine if the component is working properly. Should. For example, assume that one test, test 1, is to apply 5 volts to component D and measure the voltage output of component H. If component H has a voltage output of 3 volts, it is correct to assume that components D, E, F, G, and H are operating correctly. Of course, these assumptions may be challenged by the results of other tests. Table 2 shows the electronic data created in the computer's memory.
This example shows how such test data can be stored in a blueprint.

[0027]
Table 2
Test confirmation field Parts field
Test 1
D, E, F, G, H
Exam 2
A, I, G, L, K
Test 3 M
,A,B,C Test 4 G,H
In Table 2, when test 1 is performed, parts D, E, F, G, and H are verified to be working correctly, and when test 2 is performed, parts A, I
, G, L, and K are operating correctly.

Further prior to processing, in addition to the test and part label lookup tables, a part error code correlation lookup table should also be created. Specifically, as mentioned earlier, the parts displayed on the connectivity diagram are
During operation, it may generate error/failure codes/messages. It is necessary to store all possible error codes in a look-up table, along with identification of each component that generates each error code. Table 3 shows how such correlation data can be stored in an electronic table created in the computer's memory.

[0029]
Table 3 Error code field Component that generated the error code 01000
A
00105
B
08906
In Table 3, component A generates error code 01000, and component B generates error code 00105. Of course, one component may generate several error codes, and each such error code should also be included in the table.

Of course, component labels, testing and component error codes
The correlation lookup tables can be combined into one lookup table. Additionally, electronic storage methods other than look-up tables, such as object diagrams, may be used to store information so that the information can be accessed during processing.

After performing the pre-processing steps described above, a fault isolation algorithm 200 can be implemented, as shown in FIG. Specifically, when operating the system, if a malfunction of the system occurs, one component or many components within the system may generate an error message/code. The occurrence of an error message/code triggers algorithm 200.

Specifically, instead of implementing the system in the field, the system and the algorithm 200 within it are
Electronic communication with a computer having a computer can be set up, for example, via a telephone line using well-known methods. Thus, algorithm 200 can be implemented at a central location and used to provide fault isolation for multiple systems at each location. Of course, algorithm 200 may be implemented on an on-site computer.

Briefly, Algorithm 2 communicates the error code so that fault isolation can be performed at a remote location.
To activate 00, when an error code is generated by the system, it is read into a preselected memory location or register of a computer coupled to the system at the system location, i.e., a field computer. . When the data is present in the preselected memory location, the field computers establish contact with the central computer via telephone lines and respective modems. The central computer is at a remote location, and once communication is established between the central computer and the field computer, the central computer automatically reads preselected memory locations on the field computer. In this way, the error code data is transferred to the memory of the central computer. Once the error code data has been transferred to the central computer memory, algorithm 200 is activated,
It operates on data stored in the memory of the central computer. Such computer network systems are well known.

The result of implementing algorithm 200 is that a defective component is identified, or at least a component that is most likely to be a defective component. A technician (or possibly someone with little technical training) is then dispatched to the system site and simply replaces the identified defective parts. Therefore, the technician does not perform lengthy fault isolation operations in the field, and the system returns to operating condition with only a small delay.

Referring now to the algorithm 200 shown in FIG. 5 in more detail, after the start operation shown at start symbol 200, the next step is to check for error messages/codes, as shown at 204. That's true. This operation typically includes, for example, reading data from a field computer and storing the data in the memory of a central computer. Once the error message/code has been identified, the next step is to identify the error message/code as shown at 206.
Check the part that caused the code. Using the component error code correlation lookup table described above (see Table 3) with all possible error messages/codes corresponding to the components in it, has generated the respective error message/code.

As shown in step 208, once it is known which component generated the error code, the next step is to create a loop/code consisting of the component that generated the error message/code. The key is to check the string. The details of this process will be explained later. However, it should be mentioned that it is preferable to check one loop/string. This one loop/string consists of all the parts that generated the error message/code.

For example, regarding FIG. 4, parts E and F
and G each generate an error message/code, then check the loop made up of parts B, D, E, F, G, H, and I. All components that generated the error message/code and, if applicable, the error message/code.
By identifying a loop/string made up of a few parts that did not generate a fault, the probability that the actual defective part is contained within this loop/string is often increased. In particular, the first part that generates the error message/code may not necessarily be the actual defective part, but two parts coupled directly or through other parts as inputs to the first part. There is a high probability that the second part is actually a defective part.

Of course, in some cases, error messages/
It may not be possible to place all the parts that generated the code in one loop/string. In these cases, it may be necessary to check the string/loop of multiple components that have the component that generated the error message/code. When multiple strings/loops are identified, an algorithm 500 shown in FIG. 8 and described in more detail below can be used to identify the most suspicious components. On the other hand, if such a suspect component cannot be confirmed or is found to be working properly, the string/loop can be prioritized for testing. For example, the string/loop with the highest number of potentially defective parts would receive the highest priority for fault isolation operations, and the string/loop with the least number of potentially defective parts would receive the highest priority for performing fault isolation operations. Fault isolation tasks can be given the lowest priority. Other considerations, such as the cost associated with setting up a test for each string/loop, the probability of failure of each string/loop as determined through experience/experiment with each string/loop, etc., are also prioritized. can be a factor (the only one or one to be considered in conjunction with others) when selecting.

After checking the loop/string, step 2
As shown in 10, the already confirmed loop/string (
Determine the tests to perform on the parts, such as excluding most parts in step 208). Details regarding test confirmation will be provided later. Simply put, by removing as many parts as possible from the loop/string as potentially defective, assuming that each test takes approximately the same amount of time to perform, The time required to isolate actual defective parts is reduced. If there are differences in factors such as length of time required to perform each test, cost, etc., these factors can also be taken into account, as will be explained later. Once the test is verified, the next verified test is performed as shown at step 212.

After performing the test, if no defective parts are found, as shown at 214, the next step is to identify any parts that may still be defective, as shown at step 216. Specifically, if the tests you just performed do not verify that all components in the string/loop are working correctly, you should still check for potentially defective components. For example, if the identified loop consists of parts B, D, E, F, G, H and I, the first test carried out
If parts D, E, G, H, and I are verified to be working correctly, parts B and F remain as potentially defective parts.

Next, as shown in step 218, a test that eliminates most of the parts likely to be defective is confirmed, and the confirmed test is performed as shown in step 220. For example, in the example described above, tests that verify the operation of parts B and F would ideally be performed next. However, there is no such test, but if there is a test to verify the operation of part B, that test will be performed. If no defective parts have yet been found, as shown at step 222, operation then returns to step 216. However, steps 214 and 22
2, if no defective parts are identified, the operation ends, as indicated by the end symbol 224.

An algorithm 300 for identifying parts of a loop/string is shown in FIG. As previously mentioned, algorithm 300 is implemented in flowchart 200 (FIG. 5).
) can be used to perform step 208. However, in many other systems it may be desirable to determine which parts are members of a loop/string;
It should be appreciated that the algorithm 300 shown in FIG. 6 can be used in other such cases as well. Therefore, although we will discuss the specific case, algorithm 300
Please be aware that it has a wide range of uses.

To explain algorithm 300 in more detail, after the start operation indicated by start symbol 302, the next step 304 is to label the parts of the system as described in flowchart 100. be. With this labeling method, parts are labeled as shown in Table 1 (reproduced for ease of reference).

[0044]
Table 1 (reprinted) Part A
1 112
121111 Part B 11
112111111
Part C 111
Part D 112
Part E 1121 Part F
11211 Parts G
112111 Parts H 11
21111 Part I 112
11111 Parts J 112
12 Parts K 112121
Part L 1121211
Part M 11212111 Of course, step 304 is preferably performed off-line and prior to processing, as previously discussed. On the other hand, step 306 may be online or offline, as will be explained. Specifically, once an erroneous message/code is identified (this process is not shown in Figure 6), the erroneous code component correlation table described earlier can be used to The label of the part that generated the message/code is
Verification is performed as shown in step 306. The component that generated the error message/code is the selected component. If multiple components generate their own error messages/codes,
Steps 308 and 310 are performed for each component, or at least until a loop/string consisting of all components that generated the error message/code is identified.

As shown in step 308, once a part is selected, by sequentially deleting the rightmost alphanumeric characters of the selected part and comparing it with the labels of other parts,
Components upstream of the selected component are confirmed. for example,
Assume that part G (Table 1) is the selected part. The label of part G is 112111. After removing the rightmost digit, the label becomes 11211. This label matches part F. If the rightmost part is deleted again, it becomes label 1121. This label corresponds to part E. If you delete the rightmost part again, label 112
This matches the label of part D. Deleting the rightmost digit again results in label 11, which matches part B. Finally, removing the rightmost digit results in label 1, which matches part A. Therefore, the upstream parts of part G are parts A, B, C,
Confirmed to be D, E and F.

The next step is as shown in step 308,
By comparing the alphanumeric characters on the label of the selected part with the leftmost alphanumeric characters on the labels of other parts, the downstream parts of the selected part are identified. In the previous example, the selected part is G and its label is 11211.
It is 1. Any part label that begins with the same digits as part G is a downstream part of part G. Specifically, parts H (1121111), I (11211
111) and B (112111111) are downstream components of component G.

[0047] Part G, that is, the rule for the selected part.
The string/string is constructed from the identified downstream and upstream parts. Therefore, for part G, parts A, B
, C, D, E, F (upstream side) and parts H, I, B (downstream side). Note that part B is identified as both a downstream and an upstream part. This means that in this labeling method, part B is part B, D, E, F, G,
This is because it is the first component identified in the loop made up of H and I (see Figure 4). Furthermore, although component A is not physically connected as part of the actual loop identified above, component A is directly coupled to component B as an input. Therefore, if component A is not operating properly, component A may be the cause of the error message.

Once the downstream parts and upstream parts have been identified as described above, the identified parts and their corresponding labels are stored in preselected blocks of memory for further processing. It should be flagged or posted (this step is not shown in Figure 6). The operation then ends, as indicated by end symbol 310. In this way, the parts of the loop/string of which the selected part is a part are identified.

To further reduce on-line fault isolation processing time, all possible loops of a component can be determined according to algorithm 300 prior to processing. Specifically, each labeled component can be selected as the selected component for checking the loop for each iteration. All scheduled loop types can then be pre-stored in selected blocks of memory. Once you know which component generated the error code, you can perform a simple comparison operation: compare the label of the component that generated the error code with the component labels of the components in the scheduled loop. This allows you to check the component loop.

A plurality of loops, such as those shown in Table 4, are stored in the memory of the central computer prior to fault isolation.

[0051]
Table 4
loop#
parts
Loop 1 A
,B,C,D,E
Loop 2 B, D, E,
F loop 3
D, E, G Next, during operation, assume that parts E and F generate error codes. Error code
By comparing the component that generated the code with components constituting all possible loops, loop 2 is selected as the loop to be further processed. Specifically, loop 2
is the only loop that contains all the parts that generated the error code.

It goes without saying that other factors can also be taken into account for the selection of the loop. for example,
As mentioned previously, failure probabilities can be associated with each loop. These probabilities can be determined by experiment/experience. Even if only one component that generates an error code is a scheduled loop component,
The failure probability of a loop may be high enough (eg, 0.90) to indicate that the loop should be selected for further processing. Factors such as the cost of performing tests on each loop can also be taken into account.

An algorithm 400 for validating tests performed on loop/string components is shown in FIG. As mentioned earlier, algorithm 400
It can be used to implement steps 210 and 218 of chart 200 (FIG. 5). However, of course, in many other systems it may be desirable to determine which tests to perform on components that are members of a loop/string, and the algorithm shown in Figure 7 does this. Needless to say, it can be used in any situation. Therefore, for a particular case, algorithm 40
Please note that 0 has a wide range of uses.

Next, to explain the flowchart 400 more specifically, after the start operation indicated by the start symbol 402, the next step 404 is to label the parts as described in the flowchart 100. It is to attach. Of course, step 40
4 is preferably performed offline. Next, as shown in step 406, the next step is to identify the error code as previously described.
Check the part that caused the code. Next, upstream and downstream parts are identified as described for algorithm 300 and as shown in step 408. Thereafter, as shown at step 410, a predefined diagnostic test including any parts identified at steps 406 and 408 is verified. As mentioned earlier, this information is pre-stored in a look-up table in the computer's memory (Table 2).
reference).

For example, assume that component Y has been identified as the component that generated the error code, and that components X and Z are components that are in a loop with component Y. Further assume that the following lookup table is previously stored in the computer's electronic memory.

[0056]
Table 5
Test confirmation field Parts field
Test 1
X, Q, R, T
Exam 2
F, G, Q, S
Test 3 W
, Y, S, Z As shown in Table 5, when Test 1 is performed, it is verified whether parts X, Q, R, and T are operating correctly. For example, if Test 1 yields a negative result, this means that any one or some combination of parts X, Q, R, and T are not working properly. Of course, each test selected in this way must yield verifiable results.

According to step 410, in the present example, test 1
and 3 are confirmed. Specifically, test 1 is for part
Test 3 verifies the operation of parts Y and Z. Test 2 does not verify the operation of any suspect component.

The next step, shown as step 412, is to select for performance, for example, the predefined test with the highest number of suspect parts. The suspect part, as defined in this specification, is the same loop/part as the selected part.
Denotes a component within a string. In the current example, the suspect parts are parts X, Y, and Z. Test 3 is therefore selected for implementation. This is because when Test 3 is performed, two of the suspected parts are verified, and when Test 1 is performed, only one suspected part is verified. Even if Test 2 is performed, none of the suspected parts will be verified.

Thereafter, the operation ends, as indicated by the end symbol 414. As described with respect to flowchart 200 of FIG. 5, each iteration removes any components that are determined to be working correctly from the list of suspect components until the failure is isolated. It goes without saying that the test confirmation procedure can be repeated as many times as necessary. The test can be performed, for example, by a technician dispatched to the site of the system. Certain tests can also be performed automatically via telephone communication lines under computer control. The output test values generated by each component during each test procedure can be stored, for example, in the computer's memory. Compare the stored value with the actual value to verify that the part is working properly.

In addition to performing the test with the largest number of suspect parts, other methods of selecting the tests to be performed are also conceivable. For example, failure probabilities can be associated with each component based on data gathered from experience/experiment. The failure probabilities associated with a loop of components as described above should be distinguished from the failure probabilities associated with each individual component. Of course,
When determining the failure probability of a loop, component failure probabilities can be taken into account. For example, the following lookup table can be stored in the central computer's electrical memory prior to processing.

In Table 6, component X has the highest failure probability, component Y has the lowest failure probability, and component Z has an intermediate failure probability.

[0062] Therefore, a probability value is associated with each test. Specifically, a failure probability value is obtained for each suspect component, and each test is assigned a value equal to the highest value of any suspect component verified by the test. If the test does not verify the suspect part, the test is assigned the lowest possible value, ie, 0.0.

As an example, referring to Tables 4 and 5, the suspect parts are parts X, Y, and Z. Table 4 is a "test" table, and Table 5 is a "failure probability" table. Test 1 verifies suspect part X, and test 1 does not verify any other suspect parts. Therefore, test 1 is assigned a value of 0.86. Test 2 does not verify any suspect parts and therefore assigns Test 2 a value of 0.0. Test 3 verifies suspect parts Y and Z, which have failure probabilities of 0.43 and 0.65, respectively. Since 0.65 is greater than 0.43, test 3 is assigned a value of 0.65. Of course, other methods of combining component failure probabilities with test failure probabilities may be used. At least as an idea, the following test value assignment table may be created.

In Table 7, test 1 has the highest value (0.86), so
Test 1 is selected for implementation.

Instead of assigning a quantitative value to the probability of failure,
Qualitative values may also be used. For example, the respective ranges of quantitative values, such as 1.0 to 0.75, 0.74 to 0.
25, and the range from 0.24 to 0.00 can be assigned respective qualitative values, such as "high,""medium," and "low." Additionally, factors such as the length of time required to set up a test, the cost of performing a test, etc. can also be taken into account, eg, assigned a weight, when selecting a test to perform.

FIG. 8 shows an algorithm 500 for identifying suspect components when more than one loop/string is identified in order to isolate defective components. As mentioned previously, it may not be possible to identify a single loop that contains all potentially defective parts. Specifically, referring to algorithm 100, after the start operation shown in step 502, the next step 504 is to label the parts of the system as described for algorithm 100. Of course, step 504 is preferably performed off-line. Thereafter, as shown in step 506,
The component that generated the error code is verified as previously described. Next, the parts upstream and downstream of the confirmed part are
Also as previously discussed, the determination is made as shown in step 508. Next, as shown in step 510, two or more loops/
If the strings are confirmed, determine which parts, if any, are common to the confirmed loops/strings and label them as suspect parts. Then the final symbol 51
The operation ends as shown at 2. Of course, after confirming the suspect part, tests should be performed on the suspect part before proceeding to perform other tests on other parts, if necessary.

For example, in the system shown in FIG. 2, the following operations are performed. Specifically, for subsystem A, the following label (step 504) is generated.

[0068]
Table 8 A 1, 121111, 11211
11, 1111111, 1112111, 112111
,12111 B 11 C 12,112 D 121,1121
E 1211, 11211 F
12111,112111 G 1
11 H 1111 I 1112 J 11111, 11121
K 111111, 111211, 11
211,1211 In subsystem A, closed loops and associated components can be verified according to algorithm 300 as shown in Table 9. All possible closed loops are identified here, but this is to make the invention easier to understand, and identifying all possible closed loops is the key to algorithm 500. It is not a necessary step to carry out the process. Of course, as explained earlier, all possible loops can be verified offline to reduce online processing time.

[0069]
Table 9 Loop (I) Label 1
, 121111 Parts: 121
111(A), 12111(F), 1211(E), 1
21 (D), 12 (C) Loop (II) Label 1, 1121111 Parts: 1121111 (A), 112111 (F), 112
11(E), 1121(D), 112(C), 11(B
) Loop (III) Label 1, 111111
1 Parts: 1111111 (
A), 111111 (K), 11111 (J), 111
1(H), 111(G), 11(B) Loop (
IV) Label 1, 1112111
Parts: 1112111(A), 111211(K
), 11121 (J), 1112 (I), 111 (G)
, 11 (B) Loop (V) Label 1, 1121
11 Parts: 112111 (A
), 11211(K), 1121(D), 112(C)
, 11 (B) Loop (VI) 1, 12111
Parts: 12111(A),
1211(K), 121(D), 12(C) Similarly, for subsystem B, the labels shown in Table 10 are generated. Algorithm 1 whose label is shown in Figure 1
00, but instead of each label starting with the digit "2" to indicate a new starting part, each label starts with the symbol "$" to distinguish this set of parts from subsystem A. They differ in that they begin with . Of course, other variations of algorithm 100 are also possible.

[0070]
Table 10
G $1
G1
$11 G2
$111
J$
1111D
$12
K $1
21 B
In $11111 and $1211 subsystem B, there is no closed loop. For example, if part K "$" 121 generates a fault signal, then the following string of suspect parts is identified according to algorithm 300 (particularly at steps 308 and 310):

[0071] Parts: $1211 (B), $121 (K)
, $12 (D), $1 (G) To further illustrate, during operation, an over-temperature fault condition occurs, and part K becomes "over-temperature".
Assume that an error code is generated. A second fault condition occurring during an overtemperature condition results in a communication loop failure (this is because part K is common to both systems A and B). For this reason, parts C and F (parts C and F
is present only in subsystem A) generates an error code.

Error code information is combined with component connection pattern data to confirm suspect strings of components. That is, algorithm 300 (particularly steps 308 and 31)
0), the label for part K ($121) is used to confirm the suspect strings of the part, D and G (upstream) and B (downstream). Therefore, the suspect strings of parts for subsystem B are G, D, K, and B.

Similarly, parts C and F, which were confirmed by different error codes, have labels (12, 112) and (12, 112), respectively.
12111, 112111). Algorithm 30
0 (particularly steps 308 and 310) by determining the upstream and downstream parts for C and F;
The suspect string (or loop in this case) is part A,
Includes B, C, D, E and F.

According to step 510, common suspect parts, ie, B and D, are confirmed as suspect parts by finding the intersection of suspect strings and loops. The test involving parts B and/or D should be selected first for performance before any other tests are selected for performance. In particular, there is a high probability that parts B and/or D are actually defective parts.

The present invention facilitates simple yet accurate automated fault isolation even when a large number of error messages/codes are generated. Additionally, the present invention facilitates the identification of tests to be performed to isolate faults and can determine such tests even before a technician is dispatched to the system site.

Although preferred embodiments have been illustrated and described in the drawings, those skilled in the art will be able to make various modifications, permutations, substitutions and equivalents, both in part and in whole, without departing from the scope of the invention. can be easily considered. It is therefore intended that the scope of the invention be limited only by the claims that follow.

[Brief explanation of the drawing]

FIG. 1 is a flowchart 100 illustrating the sequence of process steps to be performed to represent component connectivity prior to processing or fault isolation.

FIG. 2 is a connection diagram for the first system.

3A and 3B are connection diagrams (or parts thereof) at different levels of the diagram shown in FIG. 2;

FIG. 4 is a connection diagram for the second system.

FIG. 5 is a flowchart showing a fault isolation algorithm.

FIG. 6 is a flowchart of an algorithm for checking parts of a loop/string.

FIG. 7 is a flowchart of an algorithm that confirms tests performed for fault isolation.

[Fig. 8] Flowchart of an algorithm for checking highly suspicious parts for fault isolation.

Claims (33)

[Claims] Claim 1: A method for isolating defective parts in a system comprising a plurality of parts, at least some of which generate error codes when a predetermined condition occurs. Faulty code generated by any component
check the code, identify which component generated each error code, identify the loop/string that contains the component that generated the error code, and Each component constituting the
determine the test to be performed on the suspect component that constitutes at least a portion of the string; execute the determined test; and if the defective component is not confirmed after performing the test, the operation of the suspect component is determined. Remove all parts of the verified loop/string and return to the process of determining the tests to perform on the suspect part, including repairing/replacing the faulty part if it is identified. Method. [Claim 2] The step of confirming which part caused each error code involves creating a diagram made up of blocks representing system parts, and checking the connectivity of the parts on the diagram. display, select the first starting part, and add the first starting part to the starting part.
identifying each child part of the starting part; assigning a label to each child part of the starting part, each label being unique for each part and identifying each child part of the part; If the connectivity of any part represented in said diagram is not indicated by a label after the step of assigning a respective label to said respective child part, another starting part is selected; , after selecting the second starting part, return to the process of checking each child part of the starting part, remembering the assigned part label, and when an error code is generated;
Determine the part label of the part that generated the error code,
2. The method of claim 1, further comprising the step of selecting the component that generated the error code as a loop/string component. 3. The first starting part is designated as label "1", the variable i is initially equal to "1", and each subsequent starting part is sequentially designated by the label (i+1). The method described in 2. [Claim 4] Alphanumeric characters starting with "1" and including the label of the parent part are sequentially assigned to the child parts.
Method described. 5. The method of claim 2, wherein the line diagram is created with a graphics editor. 6. The method of claim 2, wherein the assigned part label is stored in central computer memory. 7. The method of claim 2, wherein a component is displayed as an independent component in the diagram only if the component is capable of generating an error code. 8. The method of claim 2, wherein a component is displayed as an independent component in the diagram only if the component has a failure probability higher than a preselected failure probability. 9. The step of verifying the loop/string of a component includes sequentially deleting the rightmost alphanumeric characters of the first loop/string component label to generate a code label; The label is compared with the labels of other parts, and if there is a part label that matches the coded label, it is tagged as an upstream part, thereby identifying the part upstream of the first loop/string part. and compare the leftmost alphanumeric characters on the labels of the other parts with the alphanumeric characters on the first loop/string part label, and compare the leftmost alphanumeric characters on the labels of the other parts with the alphanumeric characters on the first loop/string part label. Claim 2, further comprising the step of identifying a component downstream of the first loop/string component by tagging any component label that matches the alphanumeric characters of the component label as a downstream component. Method described. 10. The method of claim 1, further comprising the step of identifying suspect components of the system exhibiting malfunction, wherein each component of the system generates a respective error code when malfunction occurs. Method. 11. The step of confirming highly suspicious parts includes checking at least one part that has generated an error code in each rule.
Check the loops/strings of parts that the loops/strings contain, determine whether any of the loops/strings have common parts, and if there are any common parts, be sure to suspect them. 11. The method according to claim 10, further comprising the step of confirming it as a part. [Claim 12] The step of determining a test to be performed on a suspect component constituting at least a portion of the confirmed loop/string includes confirming tests that satisfy the scheduled conditions from the list of tests, and determining the confirmed tests. 2. The method of claim 1, including the step of selecting for implementation. 13. The method of claim 12, wherein the verified test verifies correct operation of more components comprising the loop/string than any other test. 14. The method of claim 12, wherein the verified test verifies correct operation of a component that has a higher probability of failure than any other component making up the loop/string. 15. The method of claim 12, wherein the validated test is the least expensive test to perform. 16. An apparatus for isolating defective parts in a system composed of a plurality of parts in which at least some of the parts generate an error code when a predetermined state occurs. Error codes generated by parts of
means to check which component generated the respective error code, identify the loop/string that contains the component that generated the error code, and identify the loop/string within which the component generated the error code. - An apparatus having means for determining each component constituting a loop/string as a suspect component, and means for determining a test to be performed on a suspect component constituting at least a portion of the confirmed loop/string. 17. The means for confirming which component has generated each error code includes means for creating a diagram composed of blocks representing system components, and connecting the components on the diagram. means for indicating the nature of each child part, means for selecting a first starting part, means for assigning a first label to the starting part, means for identifying each child part of the starting part; means for assigning to each child part of a starting part a respective label that is unique to the part and represents the connectivity of the parts, and where the connectivity of the parts represented in the diagram is not indicated by the labels; means for selecting another starting part; means for storing assigned part labels; and when an error code occurs, determining the part label of the part that has generated the error code; 17. The apparatus as claimed in claim 16, further comprising means for selecting the component generating the cord as a loop/string component. 18. The means for identifying a loop/string of a component generates a coded label by sequentially deleting the rightmost alphanumeric characters of the first loop/string component label; The first loop/
A means of identifying the upstream component of a string component and comparing the leftmost alphanumeric characters on the other component's labels with the alphanumeric characters on the first loop/string component label. If there is a part label whose numbers match the alphanumeric characters on the first loop/string part label, it can be tagged as a downstream part of the first loop/string part. Claim 1 comprising means for confirming the parts.
7. The device according to 7. 19. The apparatus of claim 16, further comprising means for identifying suspect components of the system that have been shown to malfunction. 20. The means for confirming highly suspicious parts includes checking the at least one part that has generated an error code in each rule.
A means for identifying loops/strings of parts, such as a loop/string contains, a means for determining whether any loops/strings have common parts, and a means for suspecting any common parts. 20. The apparatus of claim 19, comprising a dense part and means for identifying. 21. The method according to claim 16, wherein the means for determining the test to be conducted includes means for confirming, from a list of tests, a test that satisfies the scheduled conditions, and means for selecting the confirmed test for execution. equipment. 22. The apparatus of claim 21, wherein the verified test verifies correct operation of more components comprising the loop/string than any other test. 23. The apparatus of claim 21, wherein the verified test verifies correct operation of a component that has a higher probability of failure than any other component making up the loop/string. 24. The apparatus of claim 21, wherein the validated test is the least expensive test to perform. 25. A method for operating a computer to isolate defective parts in a system composed of a plurality of parts in which at least some of the parts generate error codes when a predetermined state occurs. Check the error codes generated by any component of the system, check which component generated each error code, and identify the component that generated the error code among them. The loop/string is confirmed, each component that makes up the loop/string is considered a suspect component, and the tests performed on the suspect component that makes up at least a portion of the confirmed loop/string. A method comprising the step of determining. [Claim 26] The step of confirming which component has generated each error code involves creating a diagram made up of blocks representing the components of the system, and determining the connectivity of the components on the diagram. displaying, selecting a first starting part, assigning a first label to the starting part, verifying each child part of the starting part, each label being unique for each part; Assign a label to each child part of the starting part that represents the connectivity of the parts, and select another starting part if the connectivity of any part represented in the diagram is not indicated by the label. The assigned part label is memorized, and when an error code occurs, the part label of the part that generated the error code is determined, and the part that generated the error code is looped/ Claim 2 comprising a step of selecting a string component.
5. The method described in 5. 27. The step of verifying the loop/string of a component includes sequentially deleting the rightmost alphanumeric characters of the first loop/string component label to generate a code label; The upstream part of the first loop/string part is checked by comparing the label with the labels of other parts, and if there is a part label that matches the code label, it is tagged as an upstream part. Look at the parts and compare the leftmost alphanumeric characters on the labels of the other parts to the alphanumeric characters on the first loop/string part label, and compare the leftmost alphanumeric characters on the labels of the other parts to the alphanumeric characters on the first loop/string part label. A claim comprising the step of identifying a component downstream of the first loop/string component by tagging the component label as a downstream component if any component label matches the alphanumeric characters of the string component label. The method according to item 25. 28. The method of claim 25, including the step of identifying suspect components of the device that have been shown to malfunction. 29. The step of confirming highly suspicious parts includes checking each rule with at least one part that has generated an error code.
Check the loops/strings of parts that make up the loop/string, determine if any of the loops/strings have common parts, and if there are any common parts, 29. The method according to claim 28, further comprising the step of identifying a highly suspicious component. [Claim 30] Claim 2, wherein the step of determining the test to be performed includes the step of confirming tests that satisfy the scheduled conditions from the list of tests, and selecting the confirmed test for implementation.
5. The method described in 5. 31. The method of claim 25, wherein the verified test verifies correct operation of more components comprising the loop/string than any other test. 32. The method of claim 25, wherein the verified test verifies correct operation of a component that has a higher probability of failure than any other component making up the loop/string. 33. The method of claim 25, wherein the validated test is the least expensive test to perform.