Intelligent fault diagnosis method and system for crane

Abstract

The invention provides an intelligent fault diagnosis method and system for a crane, and the method comprises the steps: S1, initializing a flag bit of a fault data set, and collecting all flag bit data; the flag bit data is flag bit bytes; s2, classifying the flag bit data into a flag bit data group; collecting fault data, and classifying and summarizing the fault data to a fault data group based on the flag bit data; the fault data is Data data; s3, performing logical operation based on the fault data set and the flag bit data set to obtain a diagnosis result; s4, the diagnosis result is sent to a CMS, and then fault alarm is achieved; the CMS is a content management system. According to the method, logic correlation operation can be carried out on the faults, the source nodes where the faults occur can be directly checked out, interference item faults are shielded, then the crane fault checking speed is greatly increased, and the maintenance time of the crane is effectively shortened.

Description

Technical Field

[0001] The present invention belongs to the technical field of fault diagnosis, and in particular, relates to an intelligent fault diagnosis method and system for cranes. Background Art

[0002] In the metallurgical industry, as an important production equipment, cranes play a vital role in metallurgical production, and the stability of their operation will directly affect production efficiency.

[0003] With the popularization of intelligence and automation, the design of crane electronic control systems has become more and more complex. PLC, inverter, positioning equipment, communication equipment, and safety interlocking equipment are widely used in crane electronic control systems. Therefore, the difficulty and time of crane fault troubleshooting have been greatly increased.

[0005] At present, cranes are also widely popularizing crane safety monitoring systems, and therefore the key node data of the crane electronic control system will be collected into the PLC system for unified monitoring and management. In this way, although the crane fault alarm is more detailed, there is a correlation between the crane faults. Usually, the occurrence of one fault will lead to the occurrence of another fault. Typically, the power switch trips or shuts down, which will cause a series of related equipment to fail due to power failure. These faults will be uniformly recorded in the crane monitoring system. When the inspection system conducts fault review or troubleshooting of equipment failures, there will be too many interference items, and the main source of equipment failure cannot be identified.

[0006] This problem needs to be solved urgently. Summary of the invention

[0007] In view of the defects in the prior art, the object of the present invention is to provide an intelligent crane fault diagnosis method and system.

[0008] A crane intelligent fault diagnosis method provided by the present invention comprises:

[0009] Step S1: Initialize the flag bit of the fault data group and collect all flag bit data; the flag bit data is the flag bit byte;

[0010] Step S2: classify the flag data into flag data groups; collect fault data, and classify and summarize them into fault data groups based on the flag data; the fault data is Data data;

[0011] Step S3: performing a logical operation based on the fault data group and the flag data group to obtain a diagnosis result;

[0012] Step S4: Send the diagnosis result to CMS to implement fault alarm; the CMS is the content management system.

[0013] Preferably, in the step S1, the flag data, i.e., the node that can cause the failure state of other nodes; the storage capacity of a single flag data is 1 byte.

[0014] Preferably, in step S2, the fault data is classified according to correlation; the correlation includes: single correlation, double correlation and multiple correlation;

[0015] The single correlation means that the failure state of one node causes the failure of other nodes; the double correlation means that the failure state of one node or another node causes the failure of other nodes; the multiple correlation means that the failure state of any one of the three nodes or more causes the failure of other nodes;

[0016] In step S2, the expression of the flag bit data group is:

[0017] FlagArray=[Flag0, Flag1, Flag2...Flagn]

[0018] Among them, FlagArray represents the flag data group, Flagn represents the flag byte of the nth group, and n is a natural number;

[0019] The expression of the fault data group is:

[0020] Fault_Data_Array=[Fault_data0, Fault_data1,...Fault_datan]

[0021] Wherein, Fault_Data_Array represents a set of fault data groups, and Fault_datan represents the fault data group of the nth group;

[0022] The expression of Fault_datan is:

[0023] Fault_datan=[Flag, ID, Data0, Data1,...Datan]

[0024] Among them, Flag represents the flag byte, ID represents the identity number, which is used to mark the group of the current fault data; Datan represents the nth fault data.

[0025] Preferably, in step S3, the logic operation is an AND operation;

[0026] In the step S3, it includes:

[0027] Step S3.1: according to the number of fault data groups, obtain preset flag data and retrieve flag data of the corresponding flag data group;

[0028] Step S3.2: performing bit-by-bit AND operation on the flag byte of the flag data to determine whether the operation result is the same as the flag byte of the preset flag data. If the result is yes, no processing is performed; if the result is no, a diagnosis result is issued and cleared;

[0029] In step S3.1, the flag byte of the nth group is used as the field of the preset flag data, and the expression is:

[0030] Flagn=bN1N2N3N4N5N6N7N8

[0031] Wherein, N1 to N8 are 8 bits of the flag byte of the nth group, respectively, and the bits of the nth group of fault data related to the Flagn are set to 1; the remaining bits are set to 0;

[0032] In step S3.2, an AND operation is performed on the flag byte of the nth flag data group and the flag byte of the nth fault data group to obtain a calculation result field; a determination is made as to whether the calculation result field is the same as the field of the preset flag data; if the result is yes, no processing is performed; if the result is no, a diagnostic result is issued and cleared.

[0033] According to the present invention, a crane intelligent fault diagnosis system is provided, comprising:

[0034] Module M1: Initialize the flag bit of the fault data group and collect all flag bit data; the flag bit data is the flag bit byte;

[0035] Module M2: classify the flag data into flag data groups; collect fault data, and classify and summarize them into fault data groups based on the flag data; the fault data is Data data;

[0036] Module M3: performing a logic operation based on the fault data group and the flag data group to obtain a diagnosis result;

[0037] Module M4: Send the diagnosis result to CMS to implement fault alarm; the CMS is the content management system.

[0038] Preferably, in the module M1, the flag data, i.e., the node that can cause the fault state of other nodes; the storage capacity of a single flag data is 1 byte.

[0039] Preferably, in the module M2, the fault data is classified according to correlation; the correlation includes: single correlation, double correlation and multiple correlation;

[0040] The single correlation means that the failure state of one node causes the failure of other nodes; the double correlation means that the failure state of one node or another node causes the failure of other nodes; the multiple correlation means that the failure state of any one of the three nodes or more causes the failure of other nodes;

[0041] In the module M2, the expression of the flag bit data group is:

[0042] FlagArray=[Flag0, Flag1, Flag2...Flagn]

[0043] Among them, FlagArray represents the flag data group, Flagn represents the flag byte of the nth group, and n is a natural number;

[0044] The expression of the fault data group is:

[0045] Fault_Data_Array=[Fault_data0, Fault_data1,...Fault_datan]

[0046] Wherein, Fault_Data_Array represents a set of fault data groups, and Fault_datan represents the fault data group of the nth group;

[0047] The expression of Fault_datan is:

[0048] Fault_datan=[Flag, ID, Data0, Data1,...Datan]

[0049] Among them, Flag represents the flag byte, ID represents the identity number, which is used to mark the group of the current fault data; Datan represents the nth fault data.

[0050] Preferably, in the module M3, the logic operation is an AND operation;

[0051] The module M3 includes:

[0052] Module M3.1: according to the number of fault data groups, obtain preset flag data and retrieve flag data of corresponding flag data groups;

[0053] Module M3.2: Perform bit-by-bit AND operation on the flag byte of the flag data to determine whether the operation result is the same as the flag byte of the preset flag data. If the result is yes, no processing is performed; if the result is no, a diagnosis result is issued and cleared;

[0054] In the module M3.1, the flag byte of the nth group is used as the field of the preset flag data, and the expression is:

[0055] Flagn=bN1N2N3N4N5N6N7N8

[0056] Wherein, N1 to N8 are 8 bits of the flag byte of the nth group, respectively, and the bits of the nth group of fault data related to the Flagn are set to 1; the remaining bits are set to 0;

[0057] In the module M3.2, an AND operation is performed on the flag byte of the nth group of the flag data group and the flag byte of the nth group of the fault data group to obtain a calculation result field; it is determined whether the calculation result field is the same as the field of the preset flag data; if the result is yes, no processing is performed; if the result is no, a diagnostic result is issued and cleared.

[0058] According to a computer-readable storage medium storing a computer program provided by the present invention, the steps of the intelligent fault diagnosis method for a crane are implemented when the computer program is executed by a processor.

[0059] An electronic device provided according to the present invention includes a memory, a processor, and a computer program stored in the memory and executable on the processor. When the computer program is executed by the processor, the steps of the intelligent crane fault diagnosis method are implemented.

[0060] Compared with the prior art, the present invention has the following beneficial effects:

[0061] 1. The present invention can transfer the fault data of this group to the final fault record data group and send it to the crane monitoring system in a unified manner, thereby identifying the relevance of the faults, eliminating interfering fault items, and only exposing the most critical faults, greatly improving the troubleshooting speed of the faults.

[0062] 2. The present invention is based on AND operation, which makes the fault alarm of the crane more detailed, showing that there is correlation between the faults of the crane, and avoiding the failure of related equipment due to power failure.

[0063] 3. The present invention can perform logical correlation operations on the faults that occur, directly find out the source node where the fault occurs, shield the interference faults, and thus greatly improve the speed of crane fault detection and effectively reduce the maintenance time of the crane. BRIEF DESCRIPTION OF THE DRAWINGS

[0064] Other features, objects and advantages of the present invention will become more apparent from the detailed description of non-limiting embodiments made with reference to the following drawings:

[0065] Figure 1 A core program flow chart provided by the present invention;

[0066] Figure 2 A schematic diagram of single correlation fault logic acquisition provided by the present invention;

[0067] Figure 3 A schematic diagram of the multi-correlation fault logic acquisition provided by the present invention;

[0068] Figure 4 A schematic diagram of upstream fault data collection provided by the present invention;

[0069] Figure 5 A structural diagram of the regrouped fault data group provided by the present invention;

[0070] Figure 6 This is a structural diagram of the fault data array finally released by the present invention. DETAILED DESCRIPTION

[0071] The present invention is described in detail below in conjunction with specific embodiments. The following embodiments will help those skilled in the art to further understand the present invention, but are not intended to limit the present invention in any form. It should be noted that, for those of ordinary skill in the art, several changes and improvements can also be made without departing from the concept of the present invention. These all belong to the protection scope of the present invention.

[0072] The present invention will be based on the existing monitoring system of the current crane, re-examine the correlation between crane faults, group the fault data, independently store the correlated upstream faults and downstream faults, add a flag data bit and an index of the upstream fault data group to the downstream fault, and the fault data with uniform correlation will be grouped together.

[0073] After data collection, each group of data in the downstream data group is traversed, and the data flag bit is operated with the upstream fault data corresponding to the index of the upstream fault data group. It can identify whether the fault data of this group is caused by the upstream data. If so, ignore this group of fault data, otherwise pass this group of fault data to the final fault record data group and send it to the crane monitoring system. Then identify the relevance of the fault, eliminate interfering fault items, expose only the most critical faults, and greatly improve the troubleshooting speed.

[0074] Specifically, the faulty nodes of the crane first need to be powered to get the correct signal. If the power fails, the data collected by some nodes will be wrong, and a false fault alarm will be issued. In particular, the critical safety limit switches of the crane all use normally closed nodes. When the switch is in a normal state, the data collected by the PLC is 1, and the data collected during a fault is 0. When the power supply circuit breaker upstream of these limits is disconnected, the data collected by these limits will all be 0, that is, all fault data. Similarly, there are many cases where the downstream fault is not the original fault, but is caused by an upstream fault, or even an upstream fault of the upstream. Therefore, the faults of the crane are usually correlated. It is meaningful to eliminate the correlated faults and identify the original faults.

[0075] In other words, the present invention, through a reasonably designed data structure, reasonably performs logical operations on fault data correlation, eliminates interfering fault data items, and only exposes the most critical faults, thereby greatly improving the speed of fault detection and effectively reducing crane maintenance time.

[0076] According to a crane intelligent fault diagnosis method provided by the present invention, the execution steps of the software system thereof include:

[0077] Step 1: Initialize the flag bit of the fault data group and collect all flag bit data;

[0078] Step 2: classify the flag data into flag data groups; collect fault data, and classify and summarize them into fault data groups based on the flag data; the fault data is Data data;

[0079] Step 3: Performing a logical operation based on the fault data group and the flag bit data group to obtain a diagnosis result;

[0080] Step 4: Send the diagnosis result to CMS to implement fault alarm; the CMS is the content management system.

[0081] In other words, the overall program flow chart provided by the present invention is as follows Figure 1 As shown, the present invention firstly processes the fault data set, such as Figure 5The flag bit Flag shown is initialized. Then the status of all flag bit Flag data is collected and classified into the Flag data group. Then all fault data, that is, Data data, is collected and classified into the fault data group, and Data0~Datan in Fault0~Faultn are collected. Then logical operations are performed, and logical operations are realized by loops, enumerations, traversals, etc. The operation results are stored in the Fault_Data_Array data group. This data group is the final fault data result, which is the fault list after the relevant faults are identified, and there will be no false fault data. This data group will eventually be transmitted to the upper computer crane monitoring system to realize accurate fault alarm function.

[0082] Specifically, in step 2, the flag data and the fault data are classified as follows: the crane fault collection nodes are classified by correlation. For example, the fault state of node A will directly lead to the fault state of nodes B1 to Bn, which is called a single correlation. Figure 2 As shown; the fault state of node A or node B will directly lead to the fault state of nodes C1~Cn, which is called double correlation, as shown Figure 3 As shown, and so on, there are triple or even more correlation cases. All nodes that can cause other nodes to fail are aggregated into 1 byte, which is called flag data. 1 byte has 8 bits and can express 8 correlation flags, which can fully meet the use requirements in crane applications. The node that is ultimately affected is called the final fault data, and its data result is obtained by performing a logical operation between its own data and the flag data.

[0083] In other words, the flag data and the fault data are classified according to correlation; the correlation includes: single correlation, double correlation and multiple correlation;

[0084] The single correlation means that the fault state of one node causes the fault of other nodes; the double correlation means that the fault state of one node or another node causes the fault of other nodes; the multiple correlation means that the fault state of any one node among three nodes or more causes the fault of other nodes.

[0085] Among them, the data node used as a flag may have the identity of the final fault data, which will not conflict with this algorithm. The possible conflicting fault data and flags are stored in different data groups respectively; specifically, this process requires manual classification and aggregation according to the schematic logic of the crane to avoid conflicts.

[0086] In other words, the flag bit is not automatically identified and needs to be manually classified according to the fault alarm content. This step can be easily achieved based on the crane schematic diagram. In other words, subsequent logical operations can only be performed after manual induction.

[0087] Specifically, in step 3, the logic operation is implemented by looping, enumeration, traversal and other methods, and the operation result is stored in the data group set; it is specifically implemented as follows:

[0088] First, as described in step 2, the flag data and the fault data have been grouped according to their correlation. The grouping basis is whether there is a correlation between the flag data and the fault data. The flag data is stored in the form of bytes. The flag data group is named FlagArray and its storage method is [Flag0, Flag1, Flag2...Flagn].

[0089] Among them, each Flag is a byte, and each byte has 8 bits, that is, a flag byte can represent 8 flag states. The fault data related to the flag byte is divided into a group, and the storage order of the flag bytes is used as the index. The fault data related to the 0th flag byte is divided into the 0th group, the fault data related to the 1st flag byte is divided into the 1st group, and so on.

[0090] Each fault data group is named Fault_data, and the collection of all fault data groups is named Fault_Data_Array.

[0091] The storage format of Fault_Data_Array is [Fault_data0, Fault_data1, ... Fault_datan]. The difference between each fault data group Fault_data and the current conventional fault detection system is that each fault group is added with a Flag field and an ID field, followed by the fault data, Data0 to Datan, and each fault data group Fault_data is represented as [Flag, ID, Data0, Data1, ... Datan].

[0092] In order to facilitate retrieval, the data length of each group can be fixed-length. For example, in addition to the Flag field and the ID field, the number of subsequent fault bytes of each group of fault data is 8, indicating 8*8=64 faults. The Flag field and the ID field each occupy 1 byte, so the length of each group of fault data is 10 bytes, which can meet the fault grouping requirements of most cranes at present, that is, each Fault_data is expressed as [Flag, ID, Data0, Data1, ...Data7].

[0093] Among them, the ID field marks the group of the fault data, and the fault data array index is not used as the group. First, the fault data can be stored flexibly, so that the order of the fault data in the fault array does not affect the identification of its group. In addition, the group can be expanded. When there are too many individual related faults to be accommodated in one fault data group, the ID field and the Flag field can be set to the same data to expand the content of the group. That is, the same ID means the same group.

[0094] Secondly, there is the Flag field in the fault data group, which indicates how the faults in the group are related to the data in the Flag group.

[0095] Take Flag0, the first byte of the Flag array, as an example. This byte has 8 bits, and B0 to B7 are used to represent its 8 bits. The ID field in the fault data group related to it should be set to 0, and the Flag field is also 1 byte, also with 8 bits, represented by b0 to b7. Since the fault data in the fault data group is related to Flag0, it is not necessarily related to all bits in Flag0, for example, only B0, B1, and B5 are related, so b0, b1, and b5 of the Flag field in the fault data group need to be set to 1.

[0096] As described before, the Flag array stores flag data, which collects the nodes whose own faults will cause other related faults, and collects them uniformly in the Flag array. Therefore, the Flag array data changes in real time. The Flag field and ID field in the fault data group are preset fixed data, and its subsequent data is the fault data collected in real time. Due to the correlation, if this group of fault data is caused by the corresponding node in its related Flag array, then this group of data is considered invalid and needs to be abandoned. The implementation method is to clear all the data in this group. The judgment method or specific calculation method is to perform an AND operation on the Flag field of this group and the corresponding byte in the corresponding Flag array.

[0097] For example, in the previous example, assume that this group of fault data is the 0th group of fault data, that is, the ID field of this group of data is equal to 0, then retrieve the 0th Flag data in the Flag data, that is, the data of Flag0. It is assumed that this group of fault data is related to B0, B1, B5 of Flag0, and b0, b1, b5 of this group of Flag fields have been set to 1. Therefore, the field Flag = b00100011, assuming that all the related nodes of Flag0 are normal, then the corresponding B0, B1, B5 should all be 1, Flag0 = bxx1xxx11, where x is an irrelevant bit, and the data does not affect the operation result, then the result of the bit-by-bit AND operation of Flag in this fault data group and Flag0 is still b00100011, which is the same as the preset value of the Flag field of this fault array. This result indicates that the subsequent fault data in this fault data group is meaningful and does not need to be further processed. Assuming that Flag0=bxx0xxx11, that is, B5=0, it means that the node corresponding to B5 has failed. At this time, the result of the bit-by-bit AND operation of Flag and Flag0 in this fault data group is b00000011, which is different from the preset value of the Flag field of this fault array. This result indicates that the subsequent fault data in this fault data group will be meaningless and need to be cleared. In a similar situation, as long as any bit of B0, B1, and B5 in Flag0 is 0, the operation result will not be equal to the preset value of the Flag field of this fault array, which means that the subsequent fault data is meaningless. In this way, fault screening can be performed quickly, meaningless fault data can be eliminated, and the accuracy of the fault data displayed on the front end can be ensured.

[0098] Specifically, in step 4, the calculation result of step 3 is sent to CMS, that is, the crane host computer monitoring system, to realize the monitoring and storage of fault data.

[0099] Specifically, the fault logic collection content is as follows.

[0100] like Figure 2 The figure shows a simple single-correlation fault logic acquisition schematic diagram. S1, S2 to Sn are safety limiters, all of which are normally closed contact limiters. Their status is collected in bits B0, B1 to Bn of the fault data word Data0. S1, S2 to Sn are uniformly powered by circuit breaker F1. When F1 is normal, the data collected by S1, S2 to Sn are correct, 1 for normal and 0 for fault. When F1 is disconnected, the data collected by S1, S2 to Sn are all 0, that is, fault signals, which cannot correctly reflect the status of S1, S2 to Sn and are all false fault signals; therefore, the data of Data0 will be invalid.

[0101] like Figure 3The figure shows the fault logic collection diagram of the more common multi-correlation of cranes. The power distribution of cranes is also relatively complex, especially for large metallurgical cranes, which will distribute the power level by level to ensure power safety. Figure 3 The figure shows a two-stage power distribution diagram. S01, S02 to S0n and S11, S12 to S1n are all safety limit switches, and all are normally closed contact limit switches. The status of S01, S02 to S0n is collected in bits B0, B1 to Bn of the fault data word Data1, and the status of S11, S12 to S1n is collected in bits B0, B1 to Bn of the fault data word Data2. S01, S02 to S0n are uniformly powered by circuit breaker F21, S11, S12 to S1n are uniformly powered by circuit breaker F22, and F21 and F22 are powered by F11. When F11 and F21 are both normal, the data collected by S01, S02 to S0n is correct, 1 is normal, and 0 is faulty. When F11 and F22 are both normal, the data collected by S11, S12 to S1n is correct, 1 is normal, and 0 is faulty. Otherwise, when any of F11 and F21 fails, the data collected by S01, S02 to S0n will all be 0, that is, the fault signal is a false fault signal, and the Data1 data will be invalid. When any of F11 and F22 fails, the data collected by S11, S12 to S1n will all be 0, that is, the fault signal is a false fault signal, and the Data2 data will be invalid.

[0102] by Figure 2 and Figure 3 Based on, F1 is the correlation flag of S1, S2 to Sn, F11 and F21 are the correlation flags of S01, S02 to S0n, and F11 and F22 are the correlation flags of S11, S12 to S1n. The correlation flag signals of F1, F11, F21, F22, etc. are all collected into one data group, such as Figure 4 As shown, F1, F11, F21, and F22 are collected into bits B0, B1, B2, and B3 of Flag0 as upstream fault data storage. Data0, Data1, and Data2 are grouped into a fault data group, and the flag bit flag and index Id are added to each of them as a downstream fault data group. Figure 5 As shown, Data0, Data1, and Data2 will be stored according to the following relationship.

[0103] Fault0.Data0 = Data0;

[0104] Fault1.Data0=Data1;

[0105] Fault2.Data0 = Data2;

[0106] Data0, Data1, and Data2 flags are all Figure 4 The Flag0 shown, that is, its corresponding Id should all be 0, that is:

[0107] Fault0.Id = 0;

[0108] Fault1.Id = 0;

[0109] Fault2.Id = 0;

[0110] Data0 is only related to F1. F1 is B0 of Flag0, and the corresponding eight-bit binary is B0000 0001.

[0111] Fault0.Flag = B0000 0001;

[0112] Data1 is related to F11 and F21. F11 is B1 of Flag0, and F21 is B2 of Flag0. The corresponding eight-bit binary is B0000 0110. Therefore

[0113] Fault1.Flag = B0000 0110;

[0114] Data2 is related to F11 and F22. F11 is B1 of Flag0, and F22 is B3 of Flag0. The corresponding eight-bit binary is B0000 1010. Therefore

[0115] Fault2.Flag = B0000 1010;

[0116] Whether the final fault data is valid can be checked by performing an AND operation on the Flag of each element of the fault data group and the Flag data group element of the corresponding Id. If the result remains the same, the data is valid, otherwise it is invalid. Taking Fault0, Fault1, and Fault2 as an example, Fault0.Id, Fault1.Id, and Fault2.Id are all 0, that is, the corresponding Flag0, and the results are as follows. If F1, F11, F21, and F22 are all normal, the data of Flag0 is B0000 1111, at this time:

[0117] Fault0.Flag AND Flag0=B0000 0001, which is equal to Fault0.Flag; then Fault0.Data0 is valid.

[0118] Fault1.Flag AND Flag0=B0000 0110, equal to Fault1.Flag; then Fault1.Data0 is valid.

[0119] Fault2.Flag AND Flag0=B0000 1010, equal to Fault2.Flag; then Fault2.Data0 is valid.

[0120] If F1 is disconnected, and F11, F21, and F22 are all normal, then the data of Flag0 is B0000 1110.

[0121] Fault0.Flag AND Flag0=B0000 0000, which is not equal to Fault0.Flag; then Fault0.Data0 is invalid.

[0122] Fault1.Flag AND Flag0=B0000 0110, equal to Fault1.Flag; then Fault1.Data0 is valid.

[0123] Fault2.Flag AND Flag0=B0000 1010, equal to Fault2.Flag; then Fault2.Data0 is valid.

[0124] If F1, F11, and F21 are all normal and F22 is disconnected, the data of Flag0 is B0000 0111.

[0125] Fault0.Flag AND Flag0=B0000 0001, which is equal to Fault0.Flag; then Fault0.Data0 is valid.

[0126] Fault1.Flag AND Flag0=B0000 0110, equal to Fault1.Flag; then Fault1.Data0 is valid.

[0127] Fault2.Flag AND Flag0=B0000 0010, which is not equal to Fault2.Flag; then Fault2.Data0 is invalid.

[0128] If F1, F11, and F22 are all normal and F21 is disconnected, the data of Flag0 is B0000 1011.

[0129] Fault0.Flag AND Flag0=B0000 0001, which is equal to Fault0.Flag; then Fault0.Data0 is valid.

[0130] Fault1.Flag AND Flag0=B0000 0010, which is not equal to Fault1.Flag; then Fault1.Data0 is invalid.

[0131] Fault2.Flag AND Flag0=B0000 1010, equal to Fault2.Flag; then Fault2.Data0 is valid.

[0132] If F1, F21, and F22 are all normal and F11 is disconnected, the data of Flag0 is B0000 1101.

[0133] Fault0.Flag AND Flag0=B0000 0001, which is equal to Fault0.Flag; then Fault0.Data0 is valid.

[0134] Fault1.Flag AND Flag0=B0000 0100, which is not equal to Fault1.Flag; then Fault1.Data0 is invalid.

[0135] Fault2.Flag AND Flag0=B0000 1000, which is not equal to Fault2.Flag; then Fault2.Data0 is valid.

[0136] There are many more cases that are not listed one by one, but the final result shows that after the above logical operation, it can effectively determine whether the fault data in the Fault array is valid. The operation results will be summarized as follows Figure 6 In the Fault_Data_Array output fault data array shown in FIG. In actual situations, there are many fault data, and it is too cumbersome to calculate them one by one according to the above method. Therefore, it is usually necessary to use loops, enumerations, traversals and other methods to implement the above calculation process, but the core algorithm is the same.

[0137] The present invention also provides an intelligent fault diagnosis system for a crane, which can be implemented by executing the process steps of the intelligent fault diagnosis method for the crane, that is, technical personnel in this field can understand the intelligent fault diagnosis method for the crane as a preferred implementation of the intelligent fault diagnosis system for the crane.

[0138] Those skilled in the art know that, in addition to realizing the system and its various devices, modules, and units provided by the present invention in a purely computer-readable program code, it is entirely possible to realize the same functions in the form of logic gates, switches, application-specific integrated circuits, programmable logic controllers, and embedded microcontrollers by logically programming the method steps. Therefore, the system and its various devices, modules, and units provided by the present invention can be considered as a hardware component, and the devices, modules, and units included therein for realizing various functions can also be regarded as structures within the hardware component; the devices, modules, and units for realizing various functions can also be regarded as both software modules for realizing the method and structures within the hardware component.

[0139] The above describes the specific embodiments of the present invention. It should be understood that the present invention is not limited to the above specific embodiments, and those skilled in the art can make various changes or modifications within the scope of the claims, which does not affect the essence of the present invention. In the absence of conflict, the embodiments of the present application and the features in the embodiments can be combined with each other arbitrarily.

Claims

1. A crane intelligent fault diagnosis method, characterized in that: include: Step S1: Initialize the flag bit of the fault data group and collect all flag bit data; The flag data, i.e., the flag byte; Step S2: classifying the flag data into flag data groups; Collect fault data, and classify and summarize them into fault data groups based on the flag data; the fault data is Data data; Step S3: performing a logical operation based on the fault data group and the flag data group to obtain a diagnosis result; Step S4: Send the diagnosis result to CMS to implement fault alarm; the CMS is the content management system.

2. The intelligent crane fault diagnosis method according to claim 1 is characterized in that: In the step S1, the flag data, that is, the node that can cause the failure state of other nodes; the storage capacity of a single flag data is 1 byte.

3. The intelligent crane fault diagnosis method according to claim 2 is characterized in that: In the step S2, the fault data is classified according to relevance; In step S2, the expression of the flag bit data group is: FlagArray=[Flag0, Flag1, Flag2...Flagn] Among them, FlagArray represents the flag data group, Flagn represents the flag byte of the nth group, and n is a natural number; The expression of the fault data group is: Fault_Data_Array=[Fault_data0, Fault_data1,...Fault_datan] Wherein, Fault_Data_Array represents a set of fault data groups, and Fault_datan represents the fault data group of the nth group; The expression of Fault_datan is: Fault_datan=[Flag, ID, Data0, Data1,...Datan] Among them, Flag represents the flag byte, ID represents the identity number, which is used to mark the group of the current fault data; Datan represents the nth fault data.

4. The intelligent crane fault diagnosis method according to claim 3 is characterized in that: In the step S3, the logic operation is an AND operation; In the step S3, it includes: Step S3.1: according to the number of fault data groups, obtain preset flag data and retrieve flag data of the corresponding flag data group; Step S3.2: performing bit-by-bit AND operation on the flag byte of the flag data to determine whether the operation result is the same as the flag byte of the preset flag data. If the result is yes, no processing is performed; if the result is no, a diagnosis result is issued and cleared; In the step S3.1, the flag byte of the nth group is used as the field of the preset flag data, and the expression is: Flagn=bN1N2N3N4N5N6N7N8 Wherein, N1 to N8 are 8 bits of the flag byte of the nth group, respectively, and the bits of the nth group of fault data related to the Flagn are set to 1; the remaining bits are set to 0; In step S3.2, an AND operation is performed on the flag byte of the nth flag data group and the flag byte of the nth fault data group to obtain a calculation result field; a determination is made as to whether the calculation result field is the same as the field of the preset flag data; if the result is yes, no processing is performed; if the result is no, a diagnostic result is issued and cleared.

5. An intelligent crane fault diagnosis system, characterized in that: include: Module M1: Initialize the flag bit of the fault data group and collect all flag bit data; The flag data, i.e., the flag byte; Module M2: classify the flag data into flag data groups; collect fault data, and classify and summarize them into fault data groups based on the flag data; the fault data is Data data; Module M3: performing a logic operation based on the fault data group and the flag data group to obtain a diagnosis result; Module M4: Send the diagnosis result to CMS to implement fault alarm; the CMS is the content management system.

6. The intelligent crane fault diagnosis system according to claim 5, characterized in that: In the module M1, the flag data, namely the node that can cause the fault state of other nodes; the storage capacity of a single flag data is 1 byte.

7. The intelligent crane fault diagnosis system according to claim 6, characterized in that: In the module M2, the fault data is classified according to relevance; In the module M2, the expression of the flag bit data group is: FlagArray=[Flag0, Flag1, Flag2...Flagn] Among them, FlagArray represents the flag data group, Flagn represents the flag byte of the nth group, and n is a natural number; The expression of the fault data group is: Fault_Data_Array=[Fault_data0, Fault_data1,...Fault_datan] Wherein, Fault_Data_Array represents a set of fault data groups, and Fault_datan represents the fault data group of the nth group; The expression of Fault_datan is: Fault_datan=[Flag, ID, Data0, Data1,...Datan] Among them, Flag represents the flag byte, ID represents the identity number, which is used to mark the group of the current fault data; Datan represents the nth fault data.

8. The intelligent crane fault diagnosis system according to claim 7, characterized in that: In the module M3, the logic operation is an AND operation; The module M3 includes: Module M3.1: according to the number of fault data groups, obtain preset flag data and retrieve flag data of corresponding flag data groups; Module M3.2: Perform bit-by-bit AND operation on the flag byte of the flag data to determine whether the operation result is the same as the flag byte of the preset flag data. If the result is yes, no processing is performed; if the result is no, a diagnosis result is issued and cleared; In the module M3.1, the flag byte of the nth group is used as the field of the preset flag data, and the expression is: Flagn=bN1N2N3N4N5N6N7N8 Wherein, N1 to N8 are 8 bits of the flag byte of the nth group, respectively, and the bits of the nth group of fault data related to the Flagn are set to 1; the remaining bits are set to 0; In the module M3.2, an AND operation is performed on the flag byte of the nth group of the flag data group and the flag byte of the nth group of the fault data group to obtain a calculation result field; it is determined whether the calculation result field is the same as the field of the preset flag data; if the result is yes, no processing is performed; if the result is no, a diagnostic result is issued and cleared.

9. A computer-readable storage medium storing a computer program, characterized in that: When the computer program is executed by a processor, the steps of the intelligent crane fault diagnosis method according to any one of claims 1 to 4 are implemented.

10. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein: When the computer program is executed by a processor, the steps of the intelligent crane fault diagnosis method according to any one of claims 1 to 4 are implemented.

Images