Machine tool full life cycle management method and system

Abstract

The application discloses a kind of machine tool full life cycle management method and system, belong to equipment management technical field, solve the problem that existing machine tool management only concerns operation and maintenance link, lack of whole-process management and control, fault early warning lag and short service life;The system includes equipment account module, operation and maintenance management module, state monitoring module, predictive maintenance module and scrap management module, can realize machine tool from purchase, warehousing, installation, debugging, daily operation and maintenance, point inspection maintenance, modification and alteration until the whole-process digital management of scrapping decommissioning.Its method includes equipment filing, state monitoring, operation and maintenance execution, fault early warning and processing, performance evaluation and scrap disposal and the like steps, realize the intelligent management and control of machine tool full life cycle, reduce unplanned downtime, prolong machine tool service life, reduce maintenance cost, improve equipment overall efficiency (OEE), adapt to the machine tool management needs of various machine processing enterprises.

Description

Technical Field

[0001] This invention relates to the field of machine tool lifecycle management technology, and more specifically, to a machine tool lifecycle management method and system. Background Technology

[0002] In machine tool management, the focus of existing technologies is mainly on ensuring that information from each stage of equipment lifecycle, from procurement, warehousing, installation, commissioning, operation, inspection, maintenance, repair and modification to scrapping and decommissioning, can be continuously retained and used for subsequent management. In engineering, the equipment ledger module is generally used to store basic equipment files, configuration changes and history information, the operation and maintenance management module is used to register inspection, maintenance, repair and modification items, the status monitoring module is used to continuously collect operating data such as temperature, vibration, and energy consumption, the predictive maintenance module combines historical records with the current status to make a fault risk judgment, and the scrapping management module arranges subsequent disposal based on service life, fault conditions and maintenance investment. For example, in an automotive parts processing workshop, the same machining center may undergo spindle replacement, feed component adjustment, control system upgrade, and compensation parameter reset during the long-term processing of box-type and bracket-type parts. The site cannot create a new equipment number and management chain for this reason, nor can it allow subsequent monitoring, maintenance, risk assessment, and decommissioning to operate independently from the existing system. However, in practice, the following phenomenon repeatedly occurs in this situation: key components have been replaced, control relationships have been adjusted, and processing capacity boundaries have changed, but the system still regards the operating data, maintenance records, and life trends before and after the change as a continuous history of the same object. This leads to problems such as the status being restored after maintenance but the risk assessment continuing the old trend, the short-term performance being normal after modification but still being continuously guided by the old fault history, and the retirement judgment being inaccurate due to the mixing of records before and after the change. The root cause is that the existing processing method assumes that the management object has not changed as long as the equipment number has not changed, and lacks an identification mechanism for whether the machine tool no longer belongs to the original management object after the key change. The technical problem this application aims to solve is: how to accurately identify whether the management object of a machine tool has changed after the replacement of key components, adjustment of control relationships, or change of capability boundaries, without breaking away from the existing equipment ledger, operation and maintenance, monitoring, predictive maintenance, and scrapping management chain, so as to avoid using historical records that no longer have continuity as the basis for subsequent management of the same machine tool. Summary of the Invention

[0003] To overcome the aforementioned deficiencies in the prior art, embodiments of the present invention provide a machine tool lifecycle management method and system. By constructing digital threads corresponding to the machine tool configuration status, and associating and segmenting maintenance records, running segments, and configuration differences before and after key changes, and performing independent settlement within the threads, the problems mentioned in the background art are solved.

[0004] To achieve the above objectives, the present invention provides the following technical solution: a method for managing the entire lifecycle of a machine tool, comprising: S1. Read the equipment file, configuration record and change record of the target machine tool, merge them according to the machine tool number and extract the corresponding spindle item, feed item, control item, compensation item and attachment item at each time point in chronological order, and generate the initial digital thread; S2. Extract installation records, debugging records, inspection records, maintenance records, repair records, and modification records around the initial digital thread. Decompose each record into its function, changes, and completion time according to the record time, and write it into the corresponding thread position to generate an operation and maintenance thread. S3. Combine the operation and maintenance thread to extract the temperature data, vibration data, energy consumption data and operation status data corresponding to each running segment of the target machine tool. Divide the running segments according to the start time and end time of the running, and attach each running segment to the last operation and maintenance record arranged in chronological order before the start time of the running, which has a completion time earlier than the start time of the running, and generate the running thread. S4. For change records that include spindle replacement, feed adjustment, control rewriting, compensation reset, or attachment replacement, extract the spindle item, feed item, control item, compensation item, and attachment item of the thread positions on both sides before and after the change record and compare them item by item. If any item is inconsistent, disconnect the maintenance record and running segment after the change record from the original digital thread and generate a new digital thread. Keep writing continuously when all items are consistent and output the current thread set.

[0005] In a preferred embodiment, it further includes: S5. Based on the current thread set, perform lifecycle accumulation, maintenance processing, and decommissioning determination on the running segments, operation and maintenance records, and only allow historical records within the same thread to participate in the generation of subsequent maintenance results, continued service results, or scrapping results, and output lifecycle management results.

[0006] In a preferred embodiment, S1 includes: S11. Read the equipment file, configuration record and change record of the target machine tool, extract the machine tool number, recording time, spindle item, feed item, control item, compensation item and accessory item from each record, and expand the items with the same recording time in a fixed order of spindle item, feed item, control item, compensation item and accessory item to generate a time point configuration group; S12. For each time point configuration group, compare the same content in sequence according to the record time point. When the same content is written and changed, retain the corresponding item after the change. When the same content is not written and changed, inherit the corresponding item in the previous time point configuration group to generate the complete configuration group for each time point. S13. Connect each complete configuration group according to the recording time point, and write the complete configuration group that remains unchanged between the previous recording time point and the next recording time point as the same thread segment to generate the initial digital thread.

[0007] In a preferred embodiment, S2 includes: S21. Extract the machine tool number, record time, affected part, change content and completion time from the installation record, debugging record, inspection record, maintenance record, repair record and modification record, and merge each record according to the machine tool number to generate an operation and maintenance item group; S22. Assign the active parts in the maintenance item group to the spindle item, feed item, control item, compensation item or attachment item in the initial digital thread, and locate the thread position in the initial digital thread that has a recording time earlier than and is consistent with the corresponding item of the active part. After writing each maintenance item to the corresponding thread position, generate the part maintenance chain. S23. Connect the maintenance chains of each part according to the order of completion time, and write the maintenance items with the same completion time into the fixed order of installation record, debugging record, modification record, repair record, maintenance record and inspection record to generate maintenance threads.

[0008] In a preferred embodiment, S3 includes: S31. Extract the machine tool number, sampling time, temperature data, vibration data, energy consumption data and operating status data corresponding to each running segment of the target machine tool, merge them according to the machine tool number and arrange them according to the sampling time, and take the adjacent sampling positions where the operating status data changes as the dividing position to generate the start time and end time of each running segment. S32. For each running segment, extract the operation and maintenance records in the operation and maintenance thread whose completion time is earlier than the start time of the corresponding running segment as candidate records, and arrange each candidate record in order of completion time from late to early. Keep the first operation and maintenance record after the arrangement as the attachment record of the running segment and generate a running attachment table. S33. After writing each running segment into the corresponding connection record according to the running connection table, connect the running segments connected to the same maintenance record in order of their start time. Keep writing continuously when there are no other maintenance records between the end time of the previous running segment and the start time of the next running segment to generate running threads.

[0009] In a preferred embodiment, S4 includes: S41. For change records that include spindle replacement, feed adjustment, control rewriting, compensation reset, or attachment replacement, extract the front configuration group of the previous thread position and the back configuration group of the next thread position of the change record. Perform corresponding comparisons on the spindle item, feed item, control item, compensation item, and attachment item in the front configuration group and the back configuration group in a fixed order, and output the difference bit sequence. S42. Based on the difference bit sequence, perform forward takeover expansion on each maintenance record and each running segment after the change record in chronological order. Calculate the overlap of action items, inheritance of write items, and association of running items between each maintenance record and each running segment and the difference bit sequence. Records where the overlap of action items, inheritance of write items, and association of running items are all true are retained as original thread takeover candidates. The remaining records are marked as cut-off candidates. Output the takeover candidate table and the cut-off candidate table.

[0010] In a preferred embodiment, S4 further includes: S43. Based on the receiving candidate table and the cutting candidate table, perform reverse verification on each candidate record in reverse chronological order. Verify whether the action item between the candidate record and the previous candidate record is continuous, whether the written content is closed, and whether the running segment attachment position points back to the same change record. If all three checks are true, keep the corresponding candidate record in the original digital thread and write it continuously. If any check is false, cut the candidate record and all subsequent records from the original digital thread and generate a new digital thread. Output the thread boundary position after verification. S44. Based on the thread boundary position, the operation and maintenance records and running segments before the thread boundary position are kept within the original digital thread, and the operation and maintenance records and running segments after the thread boundary position are reorganized into a new digital thread. The subsequent contents of the change records where no thread boundary position has occurred are continuously written, and the current thread set is output.

[0011] In a preferred embodiment, S5 includes: S51. For each thread in the current thread set, extract the running segments, operation and maintenance records and change records in the thread in chronological order. Expand each running segment into corresponding consumption items according to spindle item, feed item, control item, compensation item and attachment item. Expand each operation and maintenance record into corresponding processing items. Expand the corresponding items that have been replaced in each change record into reset items. Generate thread income and expenditure sequence. S52. Based on the thread's income and expenditure sequence, perform sequential settlement on each consumption item, processing item, and reset item in chronological order. Write the same processing item before the first consumption item that follows it, write the same reset item before all subsequent consumption items, and retain consumption items that are not covered by processing items and not truncated by reset items as unclosed items, and generate a thread settlement table.

[0012] In a preferred embodiment, S5 further includes: S53. Based on the thread settlement table, perform reverse verification on each unclosed item in reverse chronological order. Check whether there is a corresponding processing item after the unclosed item, whether there is a corresponding reset item after the corresponding processing item, and whether there is another corresponding unclosed item after the corresponding reset item. If there is a corresponding processing item but no corresponding reset item, mark the corresponding item as a maintenance item. If there is a corresponding reset item and another corresponding unclosed item appears after the corresponding reset item, mark the corresponding item as a decommissioned item. If there is no unclosed item, mark the corresponding thread as a service item. Generate a thread determination table. S54. Based on the thread determination table, output the subsequent maintenance results for threads containing maintenance items, output the continued service results for threads marked as service items, and output the scrapping disposal results for threads containing decommissioning items. Limit each result to be generated only by the running segment, operation and maintenance records and change records within the corresponding thread, and output the lifecycle management results.

[0013] A machine tool lifecycle management system, the system comprising an equipment ledger module, an operation and maintenance management module, a status monitoring module, a predictive maintenance module, and a scrap management module: The equipment ledger module is used to read the equipment files, configuration records and change records of the target machine tool, merge them by machine tool number and extract the corresponding spindle items, feed items, control items, compensation items and accessory items at each time point in chronological order, and generate the initial digital thread; The operation and maintenance management module is used to extract installation records, debugging records, inspection records, maintenance records, repair records and modification records around the initial digital thread, break down each record into the part of action, the content of change and the completion time according to the record time, and write it into the corresponding thread position to generate the operation and maintenance thread; The status monitoring module is used to combine with the operation and maintenance thread to extract temperature data, vibration data, energy consumption data and operating status data corresponding to each running segment of the target machine tool. The running segments are divided according to the start time and end time of the running, and each running segment is attached to the last operation and maintenance record with a completion time earlier than the start time of the running, arranged in chronological order, to generate the running thread. The predictive maintenance module is used to extract the spindle, feed, control, compensation, and attachment items from the thread positions on both sides before and after the change record for change records that include spindle replacement, feed adjustment, control rewriting, compensation reset, or attachment replacement. It compares each item with the change record. If any item is inconsistent, it cuts off the maintenance record and running segment after the change record from the original digital thread and generates a new digital thread. When all items are consistent, it keeps writing continuously and outputs the current thread set. The scrap management module is used to perform lifespan accumulation, maintenance processing, and decommissioning determination on the running segments, operation and maintenance records, and change records within each thread according to the current thread set. Only historical records within the same thread are allowed to participate in the generation of subsequent maintenance results, continued service results, or scrapping results, and the module outputs lifecycle management results.

[0014] The technical effects and advantages of this invention are as follows: 1. This solution constructs an initial digital thread, an operation and maintenance thread, and a running thread, and performs thread switching after a critical change, so that the historical records before and after the change are reassigned according to the managed objects, thereby relatively avoiding the continued participation of discontinuous historical data in the subsequent judgment of the same machine tool; 2. Write the operation and maintenance records into the corresponding thread positions according to the parts they affect, and attach the running segments after the completed operation and maintenance records to establish the connection between the running status and the handling actions, so that subsequent maintenance analysis and status traceability have a clearer data source chain; 3. Perform item-by-item comparison of configuration groups before and after the change record, and combine overlapping action items, inheritance of write items and association of running items to perform forward expansion and reverse verification, thereby relatively improving the accuracy and interpretability of determining the thread boundary position; 4. Expand consumption items, processing items, and reset items within the thread and perform sequential settlement to form a unified settlement relationship between running consumption, operation and maintenance processing, and configuration replacement, thereby helping to improve the consistency of maintenance results, continued service results, and scrapping disposal results. 5. By limiting the lifecycle management results to be generated only from the running segments, operation and maintenance records, and change records within the corresponding thread, the impact of cross-use of historical records of different management objects on lifecycle accumulation and decommissioning determination is suppressed, thereby relatively improving the pertinence of subsequent management decisions. Attached Figure Description

[0015] Figure 1 This is a flowchart outlining the method steps of the present invention; Figure 2 This is a schematic diagram of the system module structure of the present invention. Detailed Implementation

[0016] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0017] Refer to the instruction manual appendix Figure 1-2 The present invention provides a method for managing the entire lifecycle of a machine tool, comprising: S1. Read the equipment file, configuration record and change record of the target machine tool, merge them according to the machine tool number and extract the corresponding spindle item, feed item, control item, compensation item and attachment item at each time point in chronological order, and generate the initial digital thread; This implementation method is used to organize the discrete contents of a target machine tool in equipment files, configuration records, and change records into a continuously inheritable initial digital thread. Its mechanism is as follows: first, the same target machine tool is locked using a unified corresponding key; then, the configuration contents at the same time point are organized into a comparable time-point configuration group based on the recording time point and fixed item order; subsequently, a complete configuration group is formed by retaining the same items from previous and subsequent time points through inheritance and change retention; finally, the thread segment is written according to the continuous maintenance relationship of the complete configuration group, thereby providing a unique initial carrying structure for subsequent maintenance record attachment, runtime segment attachment, and thread splitting. This implementation process includes the following steps: In S11, the equipment files, configuration records, and change records in the equipment management library are read first. The machine tool number, record time, spindle item, feed item, control item, compensation item, and accessory item are extracted. The machine tool number serves as a unified key. The spindle item includes at least the spindle model and spindle installation status. The feed item includes at least the feed component identifier and stroke parameters. The control item includes at least the control system version and control parameter set identifier. The compensation item includes at least the compensation table version and compensation activation status. The accessory item includes at least the key accessory category and accessory number. When the equipment file number, monitoring acquisition number, and maintenance number are inconsistent, the number mapping table is first called to map the equipment file number to the configuration record. The fixed mapping order from record number and configuration record number to change record number is uniformly merged. Records that fail to map are written to the exception record table and do not enter the subsequent calculations of this step. After merging, the records are grouped according to the record time point, and the spindle item, feed item, control item, compensation item and attachment item under the same record time point are expanded in a fixed order to form a time point configuration group. When there are multiple source records for the same record time point and the same content is inconsistent, the value is taken according to the fixed source order of change record, configuration record and equipment file. If the source order is the same, the value is written after the write time is retained. The time point configuration group table is output and written to the initial thread build buffer for S12 to read. In S12, the time point configuration group table is sorted according to the recorded time point and processed group by group. The current time point configuration group is compared with the previous time point configuration group item by item in the fixed order of spindle item, feed item, control item, compensation item, and attachment item. For items in the current time point configuration group that have a clear write value and whose normalization result is inconsistent with the corresponding item in the previous time point, the write value of the current time point is retained as the corresponding item after the change. For items in the current time point configuration group that do not have a write value, the corresponding item in the previous time point configuration group is inherited. For items that do not have a write value in either the current time point or the previous time point, the corresponding item is inherited. For each item with a written value, mark it as an empty item and write an empty item identifier to prevent it from participating in subsequent continuity determination. The normalization result is generated using rules with fixed field names, fixed field order, and unified encoding format, without using fuzzy matching. When an item is missing at the first record time point, the corresponding item in the device file is directly used as the baseline value to fill it in. If the item is still not present in the device file, it remains an empty item. After the above processing, the complete configuration group for each record time point is output, and the complete configuration group is written to the complete configuration group table according to the record time point for S13 to read. In S13, the complete configuration groups in the complete configuration group table are connected sequentially according to the recording time, and the thread segment division is based on whether the non-empty items between two adjacent complete configuration groups have changed. When the complete configuration group at the later recording time is consistent with the complete configuration group at the previous recording time in all non-empty items, the configuration state between the previous recording time and the later recording time is written as the continuous content of the same thread segment. When any non-empty item in the later recording time changes relative to the previous recording time, the previous thread segment ends at the later recording time and the next thread segment is generated from the later recording time. When writing threads, each thread segment is written with a thread identifier, machine number, start time, end time and corresponding complete configuration group identifier, and an initial digital thread is formed according to the recording time order. When there are time-reversed records or duplicate thread segment boundaries, time-reversed records are written to the exception record table, and duplicate boundaries are uniquely retained according to the later recording time. Finally, the initial digital thread is output for direct reading by subsequent maintenance record writing steps. Through the above processing, the configuration content in the device files, configuration records and change records that were originally scattered, inconsistent in origin and written at different times is organized into an initial digital thread with a fixed item order, fixed field scope and clear inheritance relationship. This enables subsequent operation and maintenance records to be accurately written according to the thread position, running segments to be stably attached according to the thread structure, and the configuration status before and after the change record to be compared item by item under the same object scope. In practical applications: For a machining center, the equipment file records spindle model A, control system version V1, and accessory number F1. Subsequent configuration records are written to compensation table version C3 on March 5, 2026, and change records are written to spindle model B and control system version V2 on June 18, 2026. The system first merges the three types of records by machine tool number, then generates a complete configuration group containing A, V1, C3, and F1 on March 5, 2026, and generates a complete configuration group containing B, V2, C3, and F1 on June 18, 2026. The changes in spindle and control items in the complete configuration groups before and after are used as the thread segment boundaries, ultimately obtaining the initial digital thread that can be directly inherited by subsequent maintenance and operation threads.

[0018] S2. Extract installation records, debugging records, inspection records, maintenance records, repair records, and modification records around the initial digital thread. Decompose each record into its function, changes, and completion time according to the record time, and write it into the corresponding thread position to generate an operation and maintenance thread. This implementation method is used to organize installation records, debugging records, inspection records, maintenance records, repair records, and modification records into an operation and maintenance thread that can be written into the initial digital thread. Its working mechanism is as follows: first, unified field extraction and merging of operation and maintenance records from different sources are performed, and then each operation and maintenance record is written into the corresponding item position in the initial digital thread according to its function. Subsequently, the operation and maintenance chains of each part are connected according to the completion time and fixed order, forming an operation and maintenance thread that can be attached to the running segment and directly called by subsequent thread segmentation. This implementation process includes the following steps: In S21, the installation records, debugging records, inspection records, maintenance records, repair records, and modification records in the operation and maintenance management database are read first. The machine tool number, recording time, affected area, change content, and completion time are extracted from each record. The machine tool number serves as a unified key corresponding to the initial digital thread; the recording time is used to locate the thread position to which the operation and maintenance entry belongs; the completion time is used to determine the order in which the operation and maintenance entry was written; the affected area is used to determine the configuration item category corresponding to the operation and maintenance entry; and the change content is used to characterize the specific processing content of the operation and maintenance entry. When an original operation and maintenance record involves multiple affected areas... When defining a location, the system first splits the system into multiple location maintenance entries according to the rule that one location corresponds to one maintenance entry, and retains the same source record identifier for each location maintenance entry after splitting. Then, all location maintenance entries are merged according to the machine tool number to generate maintenance entry groups. When the machine tool number is missing, the completion time is missing, or the location cannot be identified, the corresponding record is written to the exception record table and does not enter the subsequent writing process. When the record time is later than the completion time, the completion time is used as the valid execution time of the maintenance entry, and the record time is retained as the source time field. The maintenance entry group table is then output for S22 to read. In S22, the maintenance item group table and the initial digital thread are first read. The execution parts are then assigned according to the one-to-one correspondence between the action part and the configuration item category. Specifically, the spindle action part corresponds to the spindle item, the feed action part corresponds to the feed item, the control action part corresponds to the control item, the compensation action part corresponds to the compensation item, and the attachment action part corresponds to the attachment item. For each maintenance item, the thread position in the initial digital thread that has a valid execution time earlier than the maintenance item's valid execution time and whose configuration item category matches the action part is located is identified. These thread positions are then sorted by time and the last thread position is retained. As the write position, the maintenance item is written after the write position; when the part of action of the same maintenance item does not have a corresponding configuration item category in the initial digital thread, the maintenance item is marked as an unassigned item and written to the exception record table; when there are multiple writable thread positions, only the thread position with the last time sorted is retained as the unique write position, and no more repeated writing to earlier thread positions is performed; after the above processing, the main spindle part maintenance chain, feed part maintenance chain, control part maintenance chain, compensation part maintenance chain and attachment part maintenance chain are formed respectively, and the part maintenance chain list is output for S23 to read; In S23, the maintenance chain list of each part is read, and the maintenance chains of each part are connected according to the order of completion time. When the completion time is the same, the records are written in a fixed order: installation record, debugging record, modification record, repair record, maintenance record, and inspection record. This fixed order serves as the unique writing order under the same completion time; earlier maintenance entries are written first, and later maintenance entries are written later. The subsequent effective status of later-written maintenance entries on the same functional part overwrites the subsequent effective status of earlier-written maintenance entries. During the connection process, all maintenance chains of parts originating from the same machine tool number are connected according to the above order. The completion time and fixed order are merged into the same maintenance thread, and each written maintenance entry is written with a thread identifier, source record identifier, category of the affected part, effective execution time and corresponding thread position; when there are maintenance entries with reversed completion time under the same machine tool number, the reversed maintenance entry is written to the exception record table without changing the generated maintenance thread; when there are two maintenance entries with the same record category under the same completion time and the same affected part, the maintenance entry is written as the last entry after retaining the source record write time; finally, the maintenance thread is output for subsequent running segment attachment steps to read directly. Through the above processing, the originally scattered, different categories and inconsistent functions of the operation and maintenance content in the installation record, debugging record, inspection record, maintenance record, repair record and modification record are organized into operation and maintenance threads with unified corresponding keys, clear function location relationships, fixed completion time order and unique thread position, so that subsequent operation segments can be attached to the completed operation and maintenance records, and change records can also form a traceable succession relationship within the operation and maintenance thread. In practical applications: For a machining center, if there is a maintenance record on April 3, 2026, involving spindle lubrication adjustment and control parameter modification, the system first splits the maintenance record into a spindle action part maintenance item and a control action part maintenance item, and then writes them into the spindle item position and control item position in the initial digital thread respectively; if there is also a debugging record and an inspection record on the same day, the system writes them into the corresponding thread positions in a fixed order of debugging record, maintenance record, and inspection record, and finally forms an operation and maintenance thread that can be directly used for running segment attachment and subsequent thread splitting.

[0019] S3. Combine the operation and maintenance thread to extract the temperature data, vibration data, energy consumption data and operation status data corresponding to each running segment of the target machine tool. Divide the running segments according to the start time and end time of the running, and attach each running segment to the last operation and maintenance record arranged in chronological order before the start time of the running, which has a completion time earlier than the start time of the running, and generate the running thread. This implementation method is used to organize temperature data, vibration data, energy consumption data, and operating status data collected by the target machine tool during each operating segment into an operating thread that can be written to the maintenance thread. Its mechanism is as follows: first, discrete sampling records are divided into continuous operating segments according to a unified corresponding key and sampling time; then, a unique connection record is found in the maintenance thread for each operating segment; finally, the connection record is written to the operating thread according to the connection relationship and time sequence relationship, so that subsequent thread segmentation and lifecycle determination can be directly executed based on the operating segment and maintenance record succession chain. This implementation process includes the following steps: In S31, the operation sampling records corresponding to the target machine tool in the status monitoring library are first read, and the machine tool number, sampling time, temperature data, vibration data, energy consumption data, and operation status data are extracted. Among them, the machine tool number serves as a unified correspondence key with the maintenance thread, the sampling time serves as the time base for dividing the operation segment, the temperature data, vibration data, and energy consumption data serve as the monitoring load of the operation segment, and the operation status data serves as the boundary of the operation segment. Then, all operation sampling records are merged according to the machine tool number and arranged according to the sampling time under the same machine tool number. The operation status data of adjacent sampling records after the arrangement is compared one by one. When the operation status data of the later sampling record is inconsistent with the operation status data of the previous sampling record, the operation status data is checked. When the previous sampling position and the next sampling position are defined as the boundary position, the first sampling time of the consecutive identical state on the side before the boundary position is taken as the start time of the running segment, and the last sampling time of the consecutive identical state is taken as the end time of the running segment. When there are duplicate sampling records at the same sampling time, they are written to the sampling record after being retained according to the writing time. When the sampling time is missing, the machine tool number is missing, or the running status data is missing, the corresponding sampling record is written to the abnormal record table and does not participate in the running segment division. After the above processing, the running segment table containing the running segment identifier, machine tool number, start time, end time, temperature data segment, vibration data segment, energy consumption data segment, and running status segment is output for S32 to read. In S32, the run segment table and maintenance thread are first read. The start time of each run segment is extracted, and all maintenance records with completion times earlier than the start time are selected as candidate records from the maintenance thread. Then, the candidate records are arranged from latest to earliest completion times. If completion times are the same, they are first sorted in a fixed order: installation records, debugging records, modification records, repair records, maintenance records, and inspection records. The last record in the sorting result is retained as the unique connection record for that run segment. The completion time is used to determine whether a maintenance record has been added to that run segment. Before starting, a fixed order is used to eliminate ambiguity caused by multiple maintenance records being listed side-by-side at the same completion time. If there is no maintenance record with a completion time earlier than the start time before a certain operation segment, the operation segment is written into the unattached operation segment table and does not enter the current round of attachment. If there is a candidate record with an inverted completion time or an abnormal source record, the abnormal record is written into the abnormal record table and sorted according to the remaining candidate records. After the above processing, an operation attachment table consisting of operation segment identifier, attachment record identifier, attachment record completion time, and machine tool number is output for S33 to read. In S33, the runtime connection table, runtime segment table, and maintenance thread are read. Each runtime segment is written to its corresponding connection record according to the runtime connection table. All runtime segments connected to the same maintenance record are then linked sequentially by their start times. For two adjacent connected runtime segments, the end time of the preceding runtime segment and the start time of the following runtime segment are extracted. Maintenance records whose completion time falls between the end and start times are searched in the maintenance thread. If no such maintenance record exists, the preceding and following runtime segments are written continuously. If a maintenance record exists whose completion time falls within this time interval, ... The continuous writing after the previous running segment is stopped at the operation and maintenance record, and the next running segment is rewritten according to its corresponding attachment record. When writing threads, each running segment is written with a thread identifier, running segment identifier, corresponding attachment record identifier, start time, and end time to form a unique connection between the running segment and the operation and maintenance record. When the attachment record identifier in the running attachment table is inconsistent with the existing record in the operation and maintenance thread, the running segment is written to the exception record table and does not participate in the generation of running threads. Finally, the running thread is output for direct reading in the generation of thread splitting before and after subsequent change records and lifecycle management results. Through the above processing, the monitoring data stored in the status monitoring library according to the sampling time is organized into running threads with clear start time, end time and unique connection record, so that each running segment can point back to the maintenance record that was completed before it started. When the change record is split in the future, it can be determined whether the running segment still inherits the same thread along the connection chain. When determining the life cycle, it can also be limited to reusing historical running information only within the thread. In practical applications: For a machining center, if the status monitoring system continuously collects sampling records of the running status from 08:00 to 08:40, and collects records of the running status changing to standby at 08:41, then the system will take 08:00 as the start time of the running segment and 08:40 as the end time of the running segment. If there are maintenance records completed at 07:20 and inspection records completed at 07:20 in the maintenance thread, they will be sorted in a fixed order first, and then the maintenance record at the end of the sort will be retained as the attachment record for the running segment. If the next running segment starts at 09:10, and there are no new maintenance records between 08:40 and 09:10, then the two running segments will be written continuously after the same attachment record, ultimately forming a running thread that can be directly called by subsequent threads.

[0020] S4. For change records that include spindle replacement, feed adjustment, control rewriting, compensation reset, or attachment replacement, extract the spindle item, feed item, control item, compensation item, and attachment item of the thread positions on both sides before and after the change record and compare them item by item. If any item is inconsistent, cut off the operation record and running segment after the change record from the original digital thread and generate a new digital thread. Keep writing continuously when all items are consistent and output the current thread set. This implementation method is used to determine whether the original digital thread still maintains the continuity of the same managed object after the change record is applied. If the continuity is not established, the subsequent content is cut off from the original digital thread and reorganized into a new digital thread. Its working mechanism is as follows: First, a difference bit sequence is generated based on the configuration states before and after the change record. Then, the difference bit sequence is used as a constraint to perform forward expansion on the subsequent operation and maintenance records and running segments to obtain the original thread acceptance candidates and cutoff candidates. Subsequently, a reverse verification is performed on the candidate results to determine the unique thread boundary position. Finally, the original digital thread is retained and the new digital thread is reorganized according to the thread boundary position. The implementation process includes the following steps: In S41, the set of change records in the running thread is first read, and the target change record that causes the spindle item, feed item, control item, compensation item, or attachment item to be written is filtered out. The position of the last complete configuration group in the same digital thread before the target change record is written is taken as the previous thread position, and the position of the first complete configuration group formed after the target change record is written is taken as the next thread position. Then, the front configuration group of the previous thread position and the back configuration group of the next thread position are extracted. The spindle item, feed item, control item, compensation item, and attachment item in the front configuration group and the back configuration group are sorted by spindle item, feed item, control item, compensation item, attachment item, etc. The fixed-order items of compensation items and attachment items are compared one by one. Each item is compared field by field in a fixed order. If the normalization result of any field is inconsistent, the item is determined to be different. For items with differences, the difference item category, item order, value before change, and value after change are written to generate a difference bit sequence. For items without differences, no difference bit sequence is written. When the position of the next thread is missing, the back-side configuration group is constructed based on the immediate configuration state after the target change record is written. If there are empty items in the current side configuration group or the back-side configuration group, the empty items are marked with an empty item identifier and prohibited from participating in the corresponding comparison. Finally, the difference bit sequence table is output for S42 to read. In S42, the difference bit sequence table, the maintenance record after the target change record, and the running segment after the target change record are read first, and all subsequent records are forward-inherited and expanded in chronological order. For each subsequent maintenance record, its function category, written content, and corresponding thread position are extracted. For each subsequent running segment, its attached record identifier, attached record function category, and corresponding thread position are extracted. Then, the function item overlap result, the written item inheritance result, and the running item association result are calculated respectively. Among them, the function item overlap result is generated according to whether the function category of the subsequent record or the function category of the attached record is consistent with the difference item category in the difference bit sequence. If they are consistent, it is recorded as true; if they are inconsistent, it is recorded as false. The write item inheritance result is determined by whether the value of the item written in subsequent records retains the changed value after the target change record was written, and whether there are no other rewrites of the same difference item category before the subsequent record. If true, it is marked as successful; otherwise, it is marked as unsuccessful. The run item association result is determined by whether the attached record of the run segment is located after the target change record, and whether there are no other records generated between the attached record and the run segment that rewrite the same difference item category to different values. If true, it is marked as successful; otherwise, it is marked as unsuccessful. For subsequent records where all three results are true, the original thread accepting candidate identifier is written and the record is retained as an accepting candidate. For subsequent records where any one result is unsuccessful, the cutting candidate identifier is written and the record is retained as a cutting candidate. During processing, if the same subsequent record corresponds to multiple difference item categories, it is retained as an accepting candidate only when all three results for all difference item categories are true; otherwise, it is directly marked as a cutting candidate. Finally, the accepting candidate table and the cutting candidate table are output for S43 to read. In S43, the receiving candidate table and the cutting candidate table are read first, and all candidate records are arranged in reverse chronological order. Then, reverse verification is performed on each record from the last digit of the time to the first digit of the time. For each candidate record, its previous candidate record is extracted, and the following checks are made in sequence: whether the action item is continuous, whether the written content is closed, and whether the running segment attachment position points back to the same change record. Among them, continuous action item is defined as the action item category of the current candidate record and the previous candidate record being the same, and there are no other records that rewrite the action item category between them. If this condition is met, the record is valid. Closed content is defined as the changed value written in the previous candidate record not being replaced by other values ​​before the current candidate record. If this condition is met, the record is valid. When pointing back to the same change record, if the current candidate record is the running segment, its attached record is traced back along the inheritance chain of the running thread and the maintenance thread. The final change record identifier is generated if it matches the target change record identifier. If all three checks are true, the current candidate record is kept in the original digital thread and continuously written. If any check is false, the current candidate record and all subsequent candidate records are marked as cut-off records, and the position of the current candidate record is written as the thread boundary position. If the check is performed in reverse chronological order up to the first candidate record and all records are still true, no thread boundary position is generated. If a candidate record is missing a previous candidate record, the check is performed with the target change record as the starting point of the forward closure. Finally, the checked thread boundary position table is output for S44 to read. In S44, the thread demarcation position table, all operation and maintenance records after the target change record, and all running segments are read, and thread reorganization is performed according to the thread demarcation position. When the thread demarcation position exists, the operation and maintenance records and running segments before the thread demarcation position are kept in the original digital thread, and the thread identifier, machine number, and starting configuration group of the original digital thread are retained. The operation and maintenance records and running segments after the thread demarcation position are separated from the original digital thread, and the next configuration group corresponding to the thread demarcation position is used as the starting configuration group to reorganize into a new digital thread. A new thread identifier, the original digital thread identifier, and the source change record identifier are written to the new digital thread. When the thread boundary does not exist, all operation and maintenance records and running segments after the target change record are continuously written within the original digital thread without generating a new digital thread. During the separation process, the separated operation and maintenance records and running segments in the original digital thread are written with a separation identifier and a new thread identifier, so that this part of the content no longer participates in the subsequent calculations of the original digital thread. When there are multiple target change records, this step is executed one by one according to the writing time of the target change records. If a new digital thread has been generated for a previous target change record, the separation or retention of the next target change record is only performed within its own thread. Finally, the current thread set consisting of the original digital thread and the new digital thread is output for the subsequent lifecycle management result generation step to read directly. Through the above processing, the configuration status differences before and after the change record are transformed into a sequence of differences that can be verified item by item. Whether subsequent operation and maintenance records and running segments can still be inherited along the original digital thread is transformed into three clear results: overlapping action items, inheritance of write items, and association of running items. The thread boundary position is also uniquely determined through reverse verification, thus providing an executable, verifiable, and rewritable processing caliber for which subsequent contents under the same machine tool number still belong to the original management object and which subsequent contents have constituted the new management object. In practical applications: For a machining center, if the target change record on June 18, 2026, changes the spindle item from model A to model B and the control item from version V1 to version V2, the system first generates a sequence of differences between the spindle item and the control item between the front configuration group and the back configuration group. Then, it performs forward inheritance expansion on the maintenance records, upkeep records, and running segments following the change record. If a maintenance record still applies to the spindle item and the content maintains the model B correspondence, and the relevant running segment connection record is also located after the target change record, then the maintenance record and running segment enter the inheritance candidate. If a modification record subsequently appears that rewrites the control item to version V3, then the modification record and the subsequent running segment cannot meet the front-to-back closure condition during reverse verification. The system then uses the position of the modification record as the thread boundary, retains the content before it in the original digital thread, and reorganizes the content after it into a new digital thread. Finally, it outputs the current thread set that can be directly called by subsequent life accumulation, maintenance processing, and retirement determination.

[0021] S5. Based on the current thread set, perform lifecycle accumulation, maintenance processing, and decommissioning determination on the running segments, operation and maintenance records, and only allow historical records within the same thread to participate in the generation of subsequent maintenance results, continued service results, or scrapping results, and output lifecycle management results. This implementation method is used to perform unified expenditure expansion, sequential settlement, and result determination on the running segments, operation and maintenance records, and change records within each thread after the current thread set is formed. This outputs subsequent maintenance results, continued service results, or scrapping results without mixing historical records across threads. Its mechanism is as follows: First, different types of records within a thread are uniformly expanded into consumption items, processing items, and reset items. Then, same-item coverage relationships and same-item truncation relationships are established according to time sequence. Subsequently, reverse verification is performed on unclosed consumption items, and finally, the thread state is converged into maintenance items, decommissioning items, or service items. This implementation process includes the following steps: In S51, each thread in the current thread set is first read, and the running segments, operation and maintenance records, and change records within that thread are extracted in chronological order. For each running segment, based on the category of the function of the attached record, the running segment is mapped to one of the following: spindle item, feed item, control item, compensation item, or attachment item, and written as the corresponding consumption item. The consumption item includes at least the thread identifier, the source running segment identifier, the corresponding item category, the start time, and the end time. For each operation and maintenance record, based on its function category, it is written as the corresponding processing item. The processing item includes at least the thread identifier, the source operation and maintenance record identifier, the corresponding item category, and the completion time. For each change record, the corresponding item category that has been replaced is extracted and written as the corresponding reset item. The reset item includes at least the thread identifier, the source change record identifier, the corresponding item category, and the reset time. When a running segment, maintenance record, or change record involves multiple corresponding item categories, it is first split into multiple expanded items according to the rule that one corresponding item category corresponds to one expanded item; when a running segment lacks a hook record identifier, a maintenance record lacks an action part category, or a change record lacks a replacement item category, the corresponding record is written to the exception record table and does not enter this round of expansion; after the above processing, all consumption items, processing items, and reset items are connected in chronological order to generate a thread income and expenditure sequence and write it to the thread income and expenditure sequence table for S52 to read; In S52, the thread income and expenditure sequence table is first read, and sequential settlement is performed around the same thread and the same corresponding item category in chronological order. For each processing item, the first corresponding consumption item in the subsequent time sequence is retrieved, and a covering relationship identifier is written before the corresponding consumption item, indicating that the processing item takes priority over the corresponding consumption item. If there is no corresponding consumption item after the processing item, the processing item is only kept in the sequence table and no covering relationship is generated. For each reset item, all corresponding consumption items after it are retrieved, and a truncation relationship identifier is written before each corresponding consumption item, indicating that the reset item establishes a reset boundary for all corresponding consumption items after it. Then, for each consumption item, it is checked whether there is a corresponding processing item that covers the consumption item and a corresponding reset item that truncates the consumption item. The conditions for establishing an overlay relationship are: the completion time of a processing item must be before the start time of the consumption item and there must be no other reset items of the same type in between; the conditions for establishing a truncation relationship are: the reset item must be before the start time of the consumption item and after the processing item that has overlaid the consumption item. For consumption items that are not overlaid by processing items and not truncated by reset items, an unclosed item identifier is written and the item is retained as an unclosed item. For consumption items that have been overlaid by processing items or truncated by reset items, a closed item identifier is written. When there are processing items and reset items of the same type at the same time, the reset item is written first, and then the processing item is written. The final output is a thread settlement table containing thread identifiers, corresponding item categories, overlay relationships, truncation relationships, and unclosed item identifiers, which is read by S53. In S53, the thread settlement table is first read, and reverse verification is performed on unclosed items within each thread in reverse chronological order. For each unclosed item, it is first checked whether there is a corresponding processing item after it, then checked whether there is a corresponding reset item after the corresponding processing item, and then checked whether there is another unclosed item after the corresponding reset item. When there is a corresponding processing item and there is no corresponding reset item after it, the item category corresponding to the unclosed item is marked as a maintenance item, indicating that the corresponding item can still be closed through subsequent processing. When there is a corresponding reset item and another unclosed item after it, the unclosed item is marked as a maintenance item. The item category corresponding to the item is marked as a retired item, indicating that the corresponding item continues to form unclosed consumption after reset; when there are no unclosed items in a certain thread, the entire thread is marked as an in service item; when there are maintenance items and retired items in the same thread, the two types of marks are retained respectively and written into the thread decision table according to the corresponding item category, without merging or overwriting; when there are similar processing items and similar reset items after an unclosed item, but no similar unclosed item appears again after the similar reset item, the unclosed item is kept as an unresolved item and written into the exception record table, and it is prohibited from entering the result output of this round; finally, the thread decision table is output for S54 to read; In S54, the thread determination table is first read. For threads containing maintenance items, the corresponding running segments, operation and maintenance records, and change records within the thread are extracted to generate subsequent maintenance results. For threads marked as service items, all running segments, operation and maintenance records, and change records within the thread are extracted to generate continued service results. For threads containing decommissioning items, the corresponding running segments, operation and maintenance records, and change records within the thread are extracted to generate scrapping results. During the result generation process, each result is limited to being generated only by the historical records within the corresponding thread, and the running segments, operation and maintenance records, and change records from other threads are not allowed to participate in the calculation or determination. Subsequently, each result is written with a thread identifier, result category, corresponding item category, source record range, and result generation time, and these are summarized to form lifecycle management results. When a thread only has pending items and no maintenance, decommissioning, or service items, the thread is written to the pending review result table without outputting lifecycle management results. Finally, the lifecycle management results are output for direct reading by subsequent management execution or result display. Through the above processing, different records in the current thread set are uniformly converted into a thread income and expenditure sequence that can perform sequential settlement and reverse verification. The consumption, processing and reset relationships within a thread are converted into explicit overwrite and truncation relationships. Maintenance items, decommissioning items and service items are also generated by the verifiable record chain process within the same thread. In practical applications: For a new digital thread formed after a spindle item change, the system first expands the three spindle machining operation segments in the thread into spindle item consumption items, expands one spindle lubrication maintenance record into a spindle item processing item, and expands one spindle replacement record into a spindle item reset item. Then, in the sequential settlement, the maintenance record is written before the first spindle item consumption item thereafter, and the spindle replacement record is written before all subsequent spindle item consumption items. If an unclosed spindle item consumption item still appears after the spindle replacement, the system marks the spindle item as a retirement item in the reverse verification and outputs the scrapping result only based on the operation segments, maintenance records, and change records within the thread. If no unclosed spindle item consumption item appears after the spindle replacement, the thread does not generate a spindle item retirement result, and can output subsequent maintenance results or continued service results depending on whether other unclosed items still exist.

[0022] Furthermore, the present invention also includes a machine tool full lifecycle management system, the system comprising an equipment ledger module, an operation and maintenance management module, a status monitoring module, a predictive maintenance module, and a scrap management module: The equipment ledger module is used to read the equipment files, configuration records and change records of the target machine tool, merge them by machine tool number and extract the corresponding spindle items, feed items, control items, compensation items and accessory items at each time point in chronological order, and generate the initial digital thread; The operation and maintenance management module is used to extract installation records, debugging records, inspection records, maintenance records, repair records and modification records around the initial digital thread, break down each record into the part of action, the content of change and the completion time according to the record time, and write it into the corresponding thread position to generate the operation and maintenance thread; The status monitoring module is used to combine with the operation and maintenance thread to extract temperature data, vibration data, energy consumption data and operating status data corresponding to each running segment of the target machine tool. The running segments are divided according to the start time and end time of the running, and each running segment is attached to the last operation and maintenance record with a completion time earlier than the start time of the running, arranged in chronological order, to generate the running thread. The predictive maintenance module is used to extract the spindle, feed, control, compensation, and attachment items from the thread positions on both sides before and after the change record for change records that include spindle replacement, feed adjustment, control rewriting, compensation reset, or attachment replacement. It compares each item with the change record. If any item is inconsistent, it cuts off the maintenance record and running segment after the change record from the original digital thread and generates a new digital thread. When all items are consistent, it keeps writing continuously and outputs the current thread set. The scrap management module is used to perform lifespan accumulation, maintenance processing, and decommissioning determination on the running segments, operation and maintenance records, and change records within each thread according to the current thread set. Only historical records within the same thread are allowed to participate in the generation of subsequent maintenance results, continued service results, or scrapping results, and the module outputs lifecycle management results.

[0023] The working principle of this solution is as follows: First, the contents of the same machine tool in the equipment file, configuration record, and change record are organized in chronological order to form an initial digital thread, which represents the configuration status of the machine tool at different points in time. Then, the operation and maintenance records such as installation, debugging, inspection, maintenance, repair, and modification are written into this digital thread according to their function, forming an operation and maintenance thread. Next, the temperature, vibration, energy consumption, and operating status data collected during the machine tool's operation are divided into operating segments, and each operating segment is attached to the corresponding operation and maintenance record that has been completed before it begins, forming an operating thread. Based on this, the configuration status before and after key changes such as spindle replacement, feed adjustment, control rewriting, compensation reset, or accessory replacement is compared to determine whether subsequent maintenance records and running segments still belong to the same management object. If they no longer belong, they are separated from the original digital thread and a new digital thread is generated. Finally, the running consumption, maintenance processing, and configuration reset are settled within the thread. Only historical records within the same thread are allowed to participate in the generation of maintenance, continued service, or scrapping results, thereby avoiding treating machine tool status that has undergone substantial changes as the same continuous history. For example, in an automotive parts processing workshop, a machining center initially processes ordinary box-type parts for a long time. Later, the spindle was replaced, the control parameters were rewritten, and it continued to be put into production. The system first organizes the original configuration of this machine tool, all configuration changes, and information on the spindle, control, compensation, and accessories into an initial digital thread. Then, records of spindle maintenance, parameter debugging, and fault repair are written into this thread according to their corresponding parts. Next, the temperature rise, vibration, energy consumption, and operating status during operation are divided into multiple operating segments according to the sampling time and attached to the corresponding maintenance records. When the system finds that the spindle and control items have undergone substantial changes before and after the key changes, it will continue to check whether the maintenance records and operating segments after the changes still follow the original thread. If not, the subsequent content is cut off and a new digital thread is generated. In this way, the life consumption, maintenance effect, and retirement judgment before the change are only calculated in the old thread, and the operation and maintenance after the change are only calculated in the new thread. Ultimately, it can distinguish whether this is the continuous degradation of the original machine tool or the operating history re-formed under the new state after the change, making maintenance arrangements and scrap judgments more accurate.

[0024] The above description is merely a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A method for managing the entire lifecycle of a machine tool, characterized in that, include: S1. Read the equipment file, configuration record and change record of the target machine tool, merge them according to the machine tool number and extract the corresponding spindle item, feed item, control item, compensation item and attachment item at each time point in chronological order, and generate the initial digital thread; S2. Extract installation records, debugging records, inspection records, maintenance records, repair records, and modification records around the initial digital thread. Decompose each record into its function, changes, and completion time according to the record time, and write it into the corresponding thread position to generate an operation and maintenance thread. S3. Combine the operation and maintenance thread to extract the temperature data, vibration data, energy consumption data and operation status data corresponding to each running segment of the target machine tool. Divide the running segments according to the start time and end time of the running, and attach each running segment to the last operation and maintenance record arranged in chronological order before the start time of the running, which has a completion time earlier than the start time of the running, and generate the running thread. S4. For change records that include spindle replacement, feed adjustment, control rewriting, compensation reset, or attachment replacement, extract the spindle item, feed item, control item, compensation item, and attachment item of the thread positions on both sides before and after the change record and compare them item by item. If any item is inconsistent, disconnect the operation record and running segment after the change record from the original digital thread and generate a new digital thread. Keep writing continuously when all items are consistent and output the current thread set.

2. The machine tool lifecycle management method according to claim 1, characterized in that: Also includes: S5. Based on the current thread set, perform lifecycle accumulation, maintenance processing, and decommissioning determination on the running segments, operation and maintenance records, and only allow historical records within the same thread to participate in the generation of subsequent maintenance results, continued service results, or scrapping results, and output lifecycle management results.

3. The machine tool lifecycle management method according to claim 2, characterized in that: S1 includes: S11. Read the equipment file, configuration record and change record of the target machine tool, extract the machine tool number, recording time, spindle item, feed item, control item, compensation item and accessory item from each record, and expand the items with the same recording time in a fixed order of spindle item, feed item, control item, compensation item and accessory item to generate a time point configuration group; S12. For each time point configuration group, compare the same content in sequence according to the record time point. When the same content is written and changed, retain the corresponding item after the change. When the same content is not written and changed, inherit the corresponding item in the previous time point configuration group to generate the complete configuration group for each time point. S13. Connect each complete configuration group according to the recording time point, and write the complete configuration group that remains unchanged between the previous recording time point and the next recording time point as the same thread segment to generate the initial digital thread.

4. The machine tool lifecycle management method according to claim 3, characterized in that: S2 includes: S21. Extract the machine tool number, record time, affected part, change content and completion time from the installation record, debugging record, inspection record, maintenance record, repair record and modification record, and merge each record according to the machine tool number to generate an operation and maintenance item group; S22. Assign the active parts in the maintenance item group to the spindle item, feed item, control item, compensation item or attachment item in the initial digital thread, and locate the thread position in the initial digital thread that has a recording time earlier than and is consistent with the corresponding item of the active part. After writing each maintenance item to the corresponding thread position, generate the part maintenance chain. S23. Connect the maintenance chains of each part according to the order of completion time, and write the maintenance items with the same completion time into the fixed order of installation record, debugging record, modification record, repair record, maintenance record and inspection record to generate maintenance threads.

5. The machine tool lifecycle management method according to claim 4, characterized in that: S3 includes: S31. Extract the machine tool number, sampling time, temperature data, vibration data, energy consumption data and operating status data corresponding to each running segment of the target machine tool, merge them according to the machine tool number and arrange them according to the sampling time, and take the adjacent sampling positions where the operating status data changes as the dividing position to generate the start time and end time of each running segment. S32. For each running segment, extract the operation and maintenance records in the operation and maintenance thread whose completion time is earlier than the start time of the corresponding running segment as candidate records, and arrange each candidate record in order of completion time from late to early. Keep the first operation and maintenance record after the arrangement as the attachment record of the running segment and generate a running attachment table. S33. After writing each running segment into the corresponding connection record according to the running connection table, connect the running segments connected to the same maintenance record in order of their start time. Keep writing continuously when there are no other maintenance records between the end time of the previous running segment and the start time of the next running segment to generate running threads.

6. The machine tool lifecycle management method according to claim 5, characterized in that: S4 includes: S41. For change records that include spindle replacement, feed adjustment, control rewriting, compensation reset, or attachment replacement, extract the front configuration group of the previous thread position and the back configuration group of the next thread position of the change record. Perform corresponding comparisons on the spindle item, feed item, control item, compensation item, and attachment item in the front configuration group and the back configuration group in a fixed order, and output the difference bit sequence. S42. Based on the difference bit sequence, perform forward takeover expansion on each maintenance record and each running segment after the change record in chronological order. Calculate the overlap of action items, inheritance of write items, and association of running items between each maintenance record and each running segment and the difference bit sequence. Records where the overlap of action items, inheritance of write items, and association of running items are all true are retained as original thread takeover candidates. The remaining records are marked as cut-off candidates. Output the takeover candidate table and the cut-off candidate table.

7. The machine tool lifecycle management method according to claim 6, characterized in that: S4 also includes: S43. Based on the receiving candidate table and the cutting candidate table, perform reverse verification on each candidate record in reverse chronological order. Verify whether the action item between the candidate record and the previous candidate record is continuous, whether the written content is closed, and whether the running segment attachment position points back to the same change record. If all three checks are true, keep the corresponding candidate record in the original digital thread and write it continuously. If any check is false, cut the candidate record and all subsequent records from the original digital thread and generate a new digital thread. Output the thread boundary position after verification. S44. Based on the thread boundary position, the operation and maintenance records and running segments before the thread boundary position are kept within the original digital thread, and the operation and maintenance records and running segments after the thread boundary position are reorganized into a new digital thread. The subsequent contents of the change records where no thread boundary position has occurred are continuously written, and the current thread set is output.

8. The machine tool lifecycle management method according to claim 7, characterized in that: S5 includes: S51. For each thread in the current thread set, extract the running segments, operation and maintenance records and change records in the thread in chronological order. Expand each running segment into corresponding consumption items according to spindle item, feed item, control item, compensation item and attachment item. Expand each operation and maintenance record into corresponding processing items. Expand the corresponding items that have been replaced in each change record into reset items. Generate thread income and expenditure sequence. S52. Based on the thread's income and expenditure sequence, perform sequential settlement on each consumption item, processing item, and reset item in chronological order. Write the same processing item before the first consumption item that follows it, write the same reset item before all subsequent consumption items, and retain consumption items that are not covered by processing items and not truncated by reset items as unclosed items, and generate a thread settlement table.

9. A method for managing the entire lifecycle of a machine tool according to claim 8, characterized in that: S5 also includes: S53. Based on the thread settlement table, perform reverse verification on each unclosed item in reverse chronological order. Check whether there is a corresponding processing item after the unclosed item, whether there is a corresponding reset item after the corresponding processing item, and whether there is another corresponding unclosed item after the corresponding reset item. If there is a corresponding processing item but no corresponding reset item, mark the corresponding item as a maintenance item. If there is a corresponding reset item and another corresponding unclosed item appears after the corresponding reset item, mark the corresponding item as a decommissioned item. If there is no unclosed item, mark the corresponding thread as a service item. Generate a thread determination table. S54. Based on the thread determination table, output the subsequent maintenance results for threads containing maintenance items, output the continued service results for threads marked as service items, and output the scrapping disposal results for threads containing decommissioning items. Limit each result to be generated only by the running segment, operation and maintenance records and change records within the corresponding thread, and output the lifecycle management results.

10. A machine tool lifecycle management system, used to implement the machine tool lifecycle management method according to any one of claims 1-9, the system comprising an equipment ledger module, an operation and maintenance management module, a status monitoring module, a predictive maintenance module, and a scrap management module, characterized in that: The equipment ledger module is used to read the equipment files, configuration records and change records of the target machine tool, merge them by machine tool number and extract the corresponding spindle items, feed items, control items, compensation items and accessory items at each time point in chronological order, and generate the initial digital thread; The operation and maintenance management module is used to extract installation records, debugging records, inspection records, maintenance records, repair records and modification records around the initial digital thread, break down each record into the part of action, the content of change and the completion time according to the record time, and write it into the corresponding thread position to generate the operation and maintenance thread; The status monitoring module is used to combine with the operation and maintenance thread to extract temperature data, vibration data, energy consumption data and operating status data corresponding to each running segment of the target machine tool. The running segments are divided according to the start time and end time of the running, and each running segment is attached to the last operation and maintenance record with a completion time earlier than the start time of the running, arranged in chronological order, to generate the running thread. The predictive maintenance module is used to extract the spindle, feed, control, compensation, and attachment items from the thread positions on both sides before and after the change record for change records that include spindle replacement, feed adjustment, control rewriting, compensation reset, or attachment replacement. It compares each item with the change record. If any item is inconsistent, it cuts off the maintenance record and running segment after the change record from the original digital thread and generates a new digital thread. When all items are consistent, it keeps writing continuously and outputs the current thread set. The scrap management module is used to perform lifespan accumulation, maintenance processing, and decommissioning determination on the running segments, operation and maintenance records, and change records within each thread according to the current thread set. Only historical records within the same thread are allowed to participate in the generation of subsequent maintenance results, continued service results, or scrapping results, and the module outputs lifecycle management results.

Images