Software upgrading method and system of Internet of Things terminal

Abstract

The invention relates to the technical field of software upgrading, in particular to a software upgrading method and system for an Internet of Things terminal. The method comprises the following steps: acquiring software upgrade package information and terminal operation data, performing version verification, and generating terminal version difference data so as to determine software upgrade tasks, performing channel allocation on the tasks, distinguishing independent software tasks from dependent software tasks, performing chain type sorting on the dependent tasks, and generating terminal version difference data; and the head task is upgraded based on a multiplexing scheme, and meanwhile, the subsequent task and the independent software task are preloaded for parallel upgrading, and the dependent task and the independent task are synchronously scheduled, so that efficient Internet of Things terminal software upgrading is realized. The software upgrading method for the Internet of Things terminal is more efficient and more flexible.

Description

Technical Field

[0001] The present invention relates to the technical field of software upgrade, and particularly to a software upgrade method and system for Internet of Things (IoT) terminals. Background Art

[0002] The rapid development of IoT technology has led to the wide application of a large number of terminal devices in various industries. However, the subsequent software upgrade problems have become increasingly prominent. Traditional upgrade methods are often inefficient and cannot meet the requirements of rapid iteration. Especially in large-scale device management, frequent manual intervention results in waste of time and resources. In addition, the heterogeneity among devices makes unified management and upgrade more complex, causing security risks and data inconsistency problems. In existing software upgrade methods, there is often a lack of effective task scheduling and channel allocation mechanisms, resulting in insufficient utilization of resources during the upgrade process. The independence and dependence of upgrade tasks are not clearly distinguished, thus affecting the upgrade efficiency. Moreover, the lack of dynamic adjustment ability during the upgrade process often fails to cope with sudden changes in network conditions, increasing the risk of upgrade failure. Traditional methods also do not fully consider the timing relationship of tasks, leading to an unreasonable upgrade order and affecting the overall upgrade effect. Summary of the Invention

[0003] Based on this, it is necessary to provide a software upgrade method and system for IoT terminals to solve at least one of the above technical problems.

[0004] To achieve the above object, the software upgrade method for IoT terminals includes the following steps:

[0005] Step S1: Obtain software upgrade package information and terminal operation data; perform version verification on the terminal operation data and the software upgrade package to obtain terminal version difference data; perform timing task sorting on the software upgrade package information based on the terminal version difference data to obtain terminal software upgrade tasks;

[0006] Step S2: Perform channel allocation on the terminal software upgrade tasks to obtain candidate multiplexing schemes; distinguish the independence of the terminal software upgrade tasks to generate independent software tasks and dependent software tasks;

[0007] Step S3: Perform chain sorting on the dependent software tasks to obtain a dependent task timing chain; perform head task upgrade processing on the dependent task timing chain based on the candidate multiplexing schemes, and at the same time perform subsequent task upgrade preloading on the dependent task timing chain to generate upgrade dependent tasks;

[0008] Step S4: Perform parallel upgrade processing on the independent software tasks based on the candidate multiplexing schemes to generate upgrade independent tasks; perform parallel scheduling on the upgrade dependent tasks and the upgrade independent tasks to implement the intelligent software upgrade method for IoT terminals.

[0009] The present invention ensures the accuracy and effectiveness of the upgrade by obtaining software upgrade package information and terminal operation data. The implementation of version verification improves the matching degree between the upgrade package and the terminal status. The generated version difference data provides a basis for subsequent task sorting. The optimization of sequential task sorting improves the task execution efficiency. The rationality of channel allocation ensures the effective utilization of resources. The generation of candidate multiplexing schemes improves the flexibility and stability of data transmission. The implementation of task independence differentiation enhances the clarity of task management. The division of independent software tasks and dependent software tasks provides a basis for parallel processing. The chained sorting of dependent tasks optimizes the sequentiality of task execution. The upgrade processing of the head task and the preloading of subsequent tasks improve the overall upgrade fluency. The parallel upgrade processing of independent software tasks accelerates the upgrade process. The parallel scheduling of dependent tasks and independent tasks improves resource utilization rate. Finally, an intelligent software upgrade method is realized, which improves the operation efficiency and intelligent level of the Internet of Things terminal.

[0010] Preferably, step S1 includes the following steps:

[0011] Step S11: Obtain software upgrade package information and terminal operation data; perform software version identification on the terminal operation data to obtain the terminal software version identifier;

[0012] Step S12: Verify the digital signature of the software upgrade package to obtain the upgrade package credibility index; extract the version number from the software upgrade package information according to the upgrade package credibility index to generate the upgrade package version identifier;

[0013] Step S13: Perform version matching verification on the terminal software version identifier and the upgrade package version identifier to obtain the terminal version difference data;

[0014] Step S14: Analyze the upgrade requirements based on the terminal version difference data to obtain the software upgrade requirements; sort out the upgrade dependencies for the software upgrade requirements to generate an upgrade dependency relationship matrix;

[0015] Step S15: Construct a path graph for the software upgrade package information according to the upgrade dependency relationship matrix to obtain an upgrade path graph; perform task time sequence rearrangement based on the upgrade path graph to obtain the terminal software upgrade task.

[0016] The present invention ensures the system's comprehensive understanding of the current state by obtaining software upgrade package information and terminal operation data. The identification of the terminal software version identifier improves the accuracy of version management. The application of digital signature verification enhances the security and credibility of the upgrade package. The generation of the upgrade package credibility index provides an important basis for subsequent decision-making. The process of extracting the version number simplifies the information acquisition required for upgrading. The matching verification of the terminal version identifier and the upgrade package version identifier ensures version consistency. The generation of the terminal version difference data provides a basis for subsequent upgrade requirement analysis. The implementation of the upgrade requirement analysis can clarify the specific conditions required for each upgrade. The construction of the upgrade dependency matrix provides a clear view for the management of complex tasks. The construction of the path map optimizes the execution order of the upgrade tasks. The process of reordering the task time sequence improves the upgrade efficiency, and finally realizes the intelligence and high efficiency of the Internet of Things terminal software upgrade.

[0017] Preferably, step S2 includes the following steps:

[0018] Step S21: Evaluate the bandwidth requirements for the terminal software upgrade task to obtain the required bandwidth for the task; calculate the transmission limit for the required bandwidth of the task based on the preset terminal bandwidth data to generate a transmission rate limit value;

[0019] Step S22: Allocate channels for the terminal software upgrade task according to the transmission rate limit value to obtain a candidate multiplexing scheme;

[0020] Step S23: Traverse the dependencies between tasks for the terminal software upgrade task to obtain the task dependency relationship;

[0021] Step S24: Differentiate the independence of the terminal software upgrade task based on the task dependency relationship to generate independent software tasks and dependent software tasks.

[0022] The present invention ensures that the task has sufficient network resources during execution by evaluating the bandwidth requirements for the terminal software upgrade task. The evaluation of the required bandwidth for the task provides a data basis for subsequent channel allocation. The generation of the transmission rate limit value effectively controls the bandwidth usage, avoids network congestion, and improves the stability of data transmission. The determination of the candidate multiplexing scheme optimizes the channel utilization rate and improves the overall upgrade efficiency. The traversal of the dependencies between tasks provides a clear structure for task management and ensures the visualization of the dependency relationship. The implementation of the independence differentiation makes the task processing more flexible. The clear division of independent software tasks and dependent software tasks provides a basis for subsequent parallel processing, and finally realizes the high efficiency and intelligence of the Internet of Things terminal software upgrade.

[0023] Preferably, step S22 includes the following steps:

[0024] Estimate the channel resources for the terminal software upgrade task according to the transmission rate limit, and generate available channel data;

[0025] Identify the feasible transmission paths for the available channel data to obtain the feasible path data; calculate the bandwidth allocation for the feasible path data to generate the path bandwidth allocation data;

[0026] Conduct a concurrent channel limit analysis on the feasible path data based on the path bandwidth allocation data to obtain the maximum number of channels;

[0027] Perform parallel node partitioning according to the preset channel node level parameters and the maximum number of channels to generate a combinable parallel node set;

[0028] Allocate the transmission channels for the combinable parallel node set to obtain the channel allocation data; calculate the time division multiplexing ratio based on the channel allocation data to generate the time division multiplexing data;

[0029] Conduct channel switching scheduling on the channel allocation data and the time division multiplexing data to generate the channel switching timing data;

[0030] Integrate the data obtained from the above steps to obtain a candidate multiplexing scheme.

[0031] The present invention ensures a comprehensive understanding of the available network resources through the implementation of channel resource estimation. The generated available channel data provides a basis for channel allocation. The identification of feasible transmission paths optimizes the data transmission route. The process of calculating bandwidth allocation improves the rationality of resource utilization. The generation of path bandwidth allocation data ensures the maximization of bandwidth utilization for each path. The determination of the maximum number of channels provides a basis for parallel processing. The application of channel node level parameters enhances the rational allocation of nodes and improves the flexibility of the system. The generation of channel allocation data provides a clear channel usage plan for task execution. The calculation of time division multiplexing data optimizes the time utilization efficiency of channels. The implementation of channel switching scheduling ensures the continuity and stability of data transmission. The candidate multiplexing scheme formed by integrating the data obtained from the above steps provides efficient support for subsequent task execution, ultimately improving the overall performance and reliability of the Internet of Things terminal software upgrade.

[0032] Preferably, step S3 includes the following steps:

[0033] Step S31: Perform a graph theory topological mapping on the dependent software tasks to obtain a task dependency graph;

[0034] Step S32: Conduct a depth-first traversal detection on the task dependency graph to obtain a dependent task timing chain;

[0035] Step S33: Perform a multi-channel feature mapping on the dependent task timing chain according to the candidate multiplexing scheme to obtain a head task processing matrix;

[0036] Step S34: Optimize the pipelining scheduling of the dependent task timing chain based on the head task processing matrix to generate upgraded dependent tasks.

[0037] The present invention provides a clear view of the relationships between tasks through the graph-theoretic topological mapping of dependent software tasks. The generation of the task dependency graph lays the foundation for subsequent task analysis. The implementation of depth-first traversal detection ensures the comprehensive identification of task dependency relationships. The formation of the dependent task timing chain provides a clear order for task execution. The multi-channel feature mapping based on the candidate multiplexing scheme effectively improves the flexibility of resource scheduling. The generation of the head task processing matrix optimizes the priority processing of critical tasks. The application of pipelining scheduling optimization improves the efficiency of task execution. The finally generated upgraded dependent tasks ensure the coordination and smooth completion of various tasks, thereby enhancing the overall performance and reliability of the software upgrade of the Internet of Things terminal.

[0038] Preferably, step S33 includes the following steps:

[0039] Perform multi-channel feature decomposition on the dependent task timing chain to obtain task feature tensors; perform inter-channel coupling optimization on the task feature tensors to generate an optimized coupling matrix;

[0040] Perform sparse reconstruction on the optimized coupling matrix to generate a sparse feature mapping relationship; perform dynamic weight assignment according to the sparse feature mapping relationship to generate weight assignment data;

[0041] Perform multiplexing fusion processing on the weight assignment data to generate a fusion feature matrix; perform head task extraction on the fusion feature matrix to obtain the head task processing matrix.

[0042] The present invention ensures the comprehensive capture of task features by performing multi-channel feature decomposition on the dependent task timing chain. The generation of task feature tensors provides a data basis for subsequent optimization. The implementation of inter-channel coupling optimization improves the resource utilization efficiency between tasks. The formation of the optimized coupling matrix enhances the ability of collaborative task processing. The process of sparse reconstruction reduces redundant information. The generated sparse feature mapping relationship provides flexibility for dynamic adjustment. The application of dynamic weight assignment ensures the priority processing of critical tasks. The generation of weight assignment data provides a basis for multiplexing fusion. The implementation of multiplexing fusion processing improves the overall data transmission efficiency. The generation of the fusion feature matrix provides strong support for subsequent task scheduling. The process of head task extraction ensures the efficient execution of critical tasks, ultimately enhancing the overall performance and reliability of the software upgrade of the Internet of Things terminal.

[0043] Preferably, step S34 includes the following steps:

[0044] Extract features from the head task processing matrix to obtain head task features; perform pipeline mapping on the dependent task timing chain based on the head task features to obtain a dependent task pipeline;

[0045] Identify resource competition between tasks in the dependent task pipeline to obtain competing dependent tasks; perform deadlock detection on the dependent task pipeline based on the competing dependent tasks to generate conflicting dependent tasks;

[0046] Adjust the avoidance scheduling for the conflicting dependent tasks to obtain a conflict avoidance strategy; perform pipeline avoidance optimization on the dependent task timing chain according to the conflict avoidance strategy to generate an avoidance pipeline;

[0047] Identify resource sharing between tasks in the dependent task pipeline to generate cooperative dependent tasks; perform cooperative scheduling adjustment on the dependent task pipeline based on the cooperative dependent tasks to generate synchronous dependent tasks;

[0048] Perform pipeline optimization scheduling on the avoidance pipeline based on the synchronous dependent tasks to generate upgraded dependent tasks.

[0049] The present invention ensures the effective identification of key tasks by extracting features from the head task processing matrix. The generation of head task features provides a basis for subsequent mapping. The pipeline mapping of the dependent task timing chain optimizes the order and efficiency of task execution. The implementation of resource competition identification between tasks enhances the accuracy of resource management. The identification of competing dependent tasks provides a basis for deadlock detection. The generation of conflicting dependent tasks ensures the timely discovery of potential problems. The formulation of the conflict avoidance strategy effectively avoids execution delays caused by resource contention. The generation of the avoidance pipeline improves the execution fluency of tasks. The identification of cooperative dependent tasks promotes collaborative work between tasks. The generation of synchronous dependent tasks enhances the efficiency of task scheduling. The application of pipeline optimization scheduling improves the smoothness and reliability of the overall upgrade process, ultimately achieving the high efficiency and stability of the Internet of Things terminal software upgrade.

[0050] Preferably, step S4 includes the following steps:

[0051] Step S41: Simulate time slot allocation for the candidate multiplexing scheme to obtain task time-sharing scheduling data;

[0052] Step S42: Perform resource decoupling mapping on the independent software tasks according to the task time-sharing scheduling data to generate independent task priorities;

[0053] Step S43: Perform pipeline conversion on the independent software tasks based on the independent task priorities to obtain upgraded independent tasks;

[0054] Step S44: Perform concurrent scheduling optimization on the upgraded independent tasks and the upgraded dependent tasks to obtain a resource scheduling strategy;

[0055] Step S45: Optimize the load balancing of the resource scheduling policy to generate an upgrade execution sequence.

[0056] The present invention ensures the rationality of task scheduling by simulating time slot allocation for candidate multiplexing schemes. The generation of task time-sharing scheduling data provides a clear basis for subsequent resource allocation. The implementation of resource decoupling mapping improves the flexibility of independent tasks. The generation of independent task priorities ensures the priority processing of critical tasks. The application of pipeline conversion optimizes the task execution process. The formation of upgraded independent tasks promotes the efficient execution of overall tasks. The implementation of concurrent scheduling optimization enhances resource utilization. The formulation of the resource scheduling policy ensures the coordinated operation of various tasks. The application of load balancing optimization effectively avoids resource overload and idleness. The finally generated upgrade execution sequence improves the overall efficiency and stability of the Internet of Things terminal software upgrade.

[0057] Preferably, step S43 includes the following steps:

[0058] Segment the execution stage of the independent software task based on the independent task priority to obtain a segmented task sequence; calculate the stage time consumption of the segmented task sequence to generate a stage time consumption matrix;

[0059] Identify the connection points according to the stage time consumption matrix to generate stage connection points; construct a pipeline deconstruction based on the stage connection points to generate a task pipeline model;

[0060] Conduct a parallel analysis on the task pipeline model to generate a task parallel structure; configure a buffer for the task parallel structure to obtain a buffer transfer area;

[0061] Optimize the scheduling of the independent software task according to the buffer transfer area to obtain an upgraded independent task.

[0062] The present invention ensures the orderliness of task processing by segmenting the execution stage of the independent software task. The generation of the segmented task sequence provides a basis for subsequent time consumption analysis. The calculation of the stage time consumption matrix provides data support for task execution efficiency evaluation. The implementation of connection point identification optimizes the connection between tasks. The generation of stage connection points promotes the construction of the task pipeline. The process of pipeline deconstruction improves the flexibility and adaptability of task execution. The establishment of the task pipeline model lays a foundation for parallel analysis. The generation of the parallel structure optimizes resource utilization efficiency. The implementation of buffer configuration ensures the smooth transfer between tasks. The establishment of the buffer transfer area provides a basis for scheduling optimization. The finally generated upgraded independent task improves the overall efficiency and reliability of the Internet of Things terminal software upgrade.

[0063] The present invention also provides a software upgrade system for an Internet of Things (IoT) terminal, which is used to execute the software upgrade method for the IoT terminal as described above. The software upgrade system for the IoT terminal includes:

[0064] A version verification module, which is used to obtain software upgrade package information and terminal operation data; perform version verification on the terminal operation data and the software upgrade package to obtain terminal version difference data; sort the software upgrade package information based on the terminal version difference data to obtain a terminal software upgrade task;

[0065] A task allocation module, which is used to allocate channels for the terminal software upgrade task to obtain a candidate multiplexing scheme; distinguish the task independence of the terminal software upgrade task to generate independent software tasks and dependent software tasks;

[0066] A dependency sorting module, which is used to perform chain sorting on the dependent software tasks to obtain a dependent task time sequence chain; perform head task upgrade processing on the dependent task time sequence chain based on the candidate multiplexing scheme, and at the same time perform subsequent task upgrade preloading on the dependent task time sequence chain to generate upgraded dependent tasks;

[0067] A parallel scheduling module, which is used to perform parallel upgrade processing on the independent software tasks based on the candidate multiplexing scheme to generate upgraded independent tasks; perform parallel scheduling on the upgraded dependent tasks and the upgraded independent tasks to implement the intelligent software upgrade method for the IoT terminal.

[0068] Through the implementation of the version verification module, the present invention ensures the matching between the software upgrade package and the terminal operation data, avoiding upgrade failures caused by inconsistent versions. The design of the task allocation module optimizes the channel utilization rate and improves the data transmission efficiency. The clear distinction between independent software tasks and dependent software tasks provides a basis for subsequent parallel processing. The chain sorting mechanism of the dependency sorting module improves the sequentiality of task execution, ensuring that the dependency relationships between tasks are reasonably processed. The priority upgrade of the head task and the preloading of subsequent tasks effectively reduce the overall upgrade time. The parallel scheduling of dependent tasks and independent tasks realizes the optimal utilization of resources, greatly improving the software upgrade efficiency. The intelligent design of the entire system makes the upgrade process more flexible and adaptable, capable of dynamically coping with different network environments and device states, and ultimately achieving efficient and stable software upgrade for the IoT terminal. BRIEF DESCRIPTION OF THE DRAWINGS

[0069] Figure 1 It is a schematic diagram of the step flow of a software upgrade method for an IoT terminal;

[0070] Figure 2 It is a schematic diagram of the detailed implementation step flow of step S2;

[0071] Figure 3It is a schematic flowchart of the detailed implementation steps of step S3.

[0072] The realization of the purpose of the present invention, its functional characteristics and advantages will be further described in conjunction with embodiments and with reference to the accompanying drawings. Specific embodiments

[0073] The technical method of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are some but not all of the embodiments of the present invention. All other embodiments obtained by those skilled in the art within the scope of the present invention without creative work belong to the scope of protection of the present invention.

[0074] In addition, the accompanying drawings are only schematic diagrams of the present invention and are not necessarily drawn to scale. The same reference numerals in the drawings denote the same or similar parts, and thus repeated descriptions thereof will be omitted. Some of the block diagrams shown in the drawings are functional entities and do not necessarily correspond to physically or logically independent entities. The functional entities can be implemented in software, or in one or more hardware modules or integrated circuits, or in different networks and / or processor methods and / or microcontroller methods.

[0075] It should be understood that although terms such as "first" and "second" may be used herein to describe various units, these units should not be limited by these terms. These terms are only used to distinguish one unit from another. For example, without departing from the scope of the exemplary embodiments, the first unit may be referred to as the second unit, and similarly the second unit may be referred to as the first unit. The term "and / or" used herein includes any and all combinations of one or more of the listed associated items.

[0076] To achieve the above object, please refer to Figures 1 to 3 , a software upgrade method for an Internet of Things terminal, comprising the following steps:

[0077] Step S1: Obtain software upgrade package information and terminal operation data; perform version verification on the terminal operation data and the software upgrade package to obtain terminal version difference data; perform timing task sorting on the software upgrade package information based on the terminal version difference data to obtain a terminal software upgrade task;

[0078] Step S2: Perform channel allocation on the terminal software upgrade task to obtain a candidate multiplexing scheme; distinguish the task independence of the terminal software upgrade task to generate independent software tasks and dependent software tasks;

[0079] Step S3: Perform chained sorting on the dependent software tasks to obtain a dependent task time sequence chain; perform head task upgrade processing on the dependent task time sequence chain based on the candidate multiplexing scheme, and at the same time perform subsequent task upgrade preloading on the dependent task time sequence chain to generate upgraded dependent tasks;

[0080] Step S4: Perform parallel upgrade processing on the independent software tasks based on the candidate multiplexing scheme to generate upgraded independent tasks; perform parallel scheduling on the upgraded dependent tasks and the upgraded independent tasks to implement the intelligent software upgrade method for the Internet of Things terminal.

[0081] The present invention ensures the accuracy and effectiveness of the upgrade by obtaining software upgrade package information and terminal operation data. The implementation of version verification improves the matching degree between the upgrade package and the terminal state. The generated version difference data provides a basis for subsequent task sorting. The optimization of the time sequence task sorting improves the task execution efficiency. The rationality of channel allocation ensures the effective utilization of resources. The generation of the candidate multiplexing scheme improves the flexibility and stability of data transmission. The implementation of task independence differentiation enhances the clarity of task management. The division of independent software tasks and dependent software tasks provides a basis for parallel processing. The chained sorting of dependent tasks optimizes the sequentiality of task execution. The upgrade processing of the head task and the preloading of subsequent tasks improve the overall upgrade fluency. The parallel upgrade processing of independent software tasks accelerates the upgrade process. The parallel scheduling of dependent tasks and independent tasks improves the resource utilization rate, and finally realizes an intelligent software upgrade method, improving the operation efficiency and intelligent level of the Internet of Things terminal.

[0082] In the embodiment of the present invention, the software upgrade method for the Internet of Things terminal includes the following steps:

[0083] Step S1: Obtain software upgrade package information and terminal operation data; perform version verification on the terminal operation data and the software upgrade package to obtain terminal version difference data; perform time sequence task sorting on the software upgrade package information based on the terminal version difference data to obtain terminal software upgrade tasks;

[0084] In this embodiment, the running data of the terminal device and the corresponding software upgrade package information are obtained. The detailed content of the upgrade package is obtained from the server or storage device through network requests or local reading. The upgrade package includes information such as version number, size, and file checksum. The terminal running data includes the operating system version of the current device, the installed application program versions, and the hardware configuration information. After obtaining, the version number in the software upgrade package is compared with the version number currently running on the terminal. If the versions are inconsistent, version differentiation processing is performed to obtain terminal version difference data. The version difference data represents the software content difference between the current software on the terminal and the software in the upgrade package. The difference data includes information such as new functions, fixed vulnerabilities, and performance optimizations. Based on these difference data, the timing sorting of tasks is performed, and each task in the upgrade package is sorted according to priority and dependency relationships to obtain the terminal software upgrade tasks. During the sorting process, factors such as the urgency of the tasks, dependency relationships, and resource consumption are considered to ensure that the upgrade tasks are executed in the most appropriate time order, thereby ensuring the efficiency and stability of the upgrade process. Finally, a list containing all upgrade tasks is obtained. Each task in the list corresponds to an upgrade operation, such as upgrading the operating system, installing patches, replacing application programs, etc. Each task has a clear execution order and time limit.

[0085] Step S2: Perform channel allocation on the terminal software upgrade tasks to obtain candidate multiplexing schemes; distinguish the task independence of the terminal software upgrade tasks to generate independent software tasks and dependent software tasks;

[0086] In this embodiment, after the terminal software upgrade task list is generated, the operation of channel allocation is performed. The channel allocation is carried out according to the network bandwidth, hardware performance of the terminal device, and the size of the tasks. First, it is divided according to the bandwidth required by each task. If some tasks are large and have high bandwidth requirements, they are allocated to channels with sufficient bandwidth. Smaller tasks can share channels with smaller bandwidth. After the channel allocation, the terminal software upgrade tasks are divided into multiple different channel schemes, and each scheme runs independently to reduce interference between tasks. After completing the channel allocation, the tasks are distinguished according to the execution independence of the tasks. Independent tasks refer to tasks that can be executed alone and do not affect other tasks, such as updating the operating system and installing some application programs. Dependent tasks need to be preceded by other tasks to be executed, such as database updates or system environment configuration. By analyzing the relationships between tasks, it is judged which tasks can be executed independently and which need dependent tasks to be executed first. Finally, independent software tasks and dependent software tasks are generated, and it is ensured that the independent tasks and dependent tasks can be executed in parallel in the optimal way, generating two task categories, each category contains multiple tasks, and the execution order and dependency relationships between the tasks are clearly marked.

[0087] Step S3: Perform chain sorting on the dependent software tasks to obtain a dependent task time sequence chain; perform head task upgrade processing on the dependent task time sequence chain based on the candidate multiplexing scheme, and at the same time perform subsequent task upgrade preloading on the dependent task time sequence chain to generate upgraded dependent tasks;

[0088] In this embodiment, after generating the dependent software tasks, chain sorting is first performed. Chain sorting arranges the dependent software tasks in order by analyzing the dependency relationship. Each task in the dependency chain will be sorted according to the completion order of the dependent tasks. After chain sorting, a dependent task time sequence chain is obtained. Then, according to the candidate multiplexing scheme, upgrade processing is performed on the head task in the dependent task time sequence chain. The head task is usually the first task in the entire dependency chain, representing the start of the entire dependency chain. The upgrade processing includes analyzing the resource allocation, scheduling optimization, and execution time of the task to ensure that the head task can be completed in the shortest time and smoothly start subsequent tasks. During the processing, the resource allocation of the head task will be dynamically adjusted according to the hardware performance, bandwidth status, etc. of the terminal to ensure the stable execution of the task. At the same time, upgrade preloading is also performed on the subsequent tasks in the dependent task time sequence chain. The preloading process is to preload the resources required by the subsequent tasks in advance, such as software packages, configuration files, running environments, etc. This preloading operation can significantly reduce the waiting time of the subsequent tasks and ensure that the entire upgrade process is more efficient. Finally, a complete list of upgraded dependent tasks is generated, which contains all the head tasks and subsequent tasks, and each task has been preprocessed according to the dependency relationship and execution order to ensure smooth execution.

[0089] Step S4: Perform parallel upgrade processing on the independent software tasks based on the candidate multiplexing scheme to generate upgraded independent tasks; perform parallel scheduling on the upgraded dependent tasks and the upgraded independent tasks to implement the intelligent software upgrade method for the Internet of Things terminal.

[0090] In this embodiment, after the division of independent software tasks is completed, according to the candidate multiplexing scheme, parallel upgrade processing is performed on the independent software tasks. First, the resource requirements and execution time of each independent task are analyzed. The resource requirements of the task mainly include factors such as computing power, memory, and storage space, ensuring that the tasks do not interfere with each other and can make full use of the hardware resources of the terminal device. Then, these independent tasks are reasonably allocated according to the execution time and resource consumption of the tasks, ensuring that high-load tasks are processed preferentially, and lighter tasks can be processed in parallel when other tasks are executing. By dynamically allocating channels and computing resources, the parallelism of tasks is maximized, thereby reducing the overall upgrade time. When task parallel scheduling is performed, the conflicts and dependencies between tasks also need to be considered. For tasks that interfere with each other, scheduling is performed through a time window method to avoid occupying the same resources at the same time. Finally, a scheduling table containing all parallel execution tasks is obtained. The scheduling table clearly lists the execution time, resource allocation, and execution order of each task, ensuring that all tasks are completed in the shortest time, thereby implementing the intelligent software upgrade method for the Internet of Things terminal.

[0091] Preferably, step S1 includes the following steps:

[0092] Step S11: Obtain software upgrade package information and terminal operation data; perform software version identification on the terminal operation data to obtain the terminal software version identifier;

[0093] Step S12: Perform digital signature verification on the software upgrade package to obtain the upgrade package credibility index; extract the version number from the software upgrade package information according to the upgrade package credibility index to generate the upgrade package version identifier;

[0094] Step S13: Perform version matching verification on the terminal software version identifier and the upgrade package version identifier to obtain the terminal version difference data;

[0095] Step S14: Analyze the upgrade requirements based on the terminal version difference data to obtain the software upgrade requirements; sort out the upgrade dependencies for the software upgrade requirements to generate the upgrade dependency relationship matrix;

[0096] Step S15: Construct a path graph for the software upgrade package information according to the upgrade dependency relationship matrix to obtain the upgrade path graph; perform task timing rearrangement based on the upgrade path graph to obtain the terminal software upgrade task.

[0097] In this embodiment, the current running data of the terminal device is read through a network interface or local storage, including information such as the operating system version, installed application versions, hardware configuration, etc. The obtained data is stored in JSON or XML format, ensuring that the data fields include the current terminal operating system version number, hardware type, detailed information of installed components, etc. By parsing the log file of the terminal device or pulling terminal data from a remote management system through an API interface, after reading the terminal running information, software version identification is performed. Specifically, during implementation, the terminal device will compare with a database through a specific version management module to determine the version number of the current terminal software and generate a version identifier. The software version identifier forms a unique identifier by verifying the difference between the current version number and a known standard version number, and is stored in memory for subsequent upgrade operation identification and version control. The upgrade package information is obtained through remote download or storage media, and the upgrade package is parsed to read detailed data such as the version number, file format, patch information, etc. contained in it. After obtaining the software upgrade package, first, digital signature verification of the upgrade package is performed. Encryption algorithms such as RSA or ECC are used to verify the signature of the upgrade package to ensure that the upgrade package has not been tampered with and its source is trustworthy. During the signature verification process, first, the signature in the upgrade package is verified using the public key. If the signature verification passes, it indicates that the integrity and source of the upgrade package are trustworthy. Next, the version number data in the upgrade package is extracted. The version number is usually included in the metadata of the upgrade package in string form. Standard parsing tools, such as JSON parsing libraries or XML parsers, are used to extract the version number of the upgrade package and generate an upgrade package version identifier. The version number identifier is compared with the current version number of the terminal to help further confirm the differences in this upgrade. Finally, based on the signature verification result and version number information, a credibility index for the upgrade package is generated. The credibility index is comprehensively evaluated based on multiple factors such as the success or failure of signature verification, source authentication, and version number differences, and the credibility value of the upgrade package is marked. Upgrade packages with a high credibility value will be processed first, while packages with a low credibility will require further manual review or withdrawal. The built-in version management module or an external interface is used to directly compare the current version number of the terminal with the version number of the upgrade package. If the version numbers are the same, it indicates that the terminal does not need to be upgraded, and the subsequent steps are skipped. If the version numbers are different, it enters the version difference analysis phase. The functional differences, fixed vulnerabilities, updated modules, etc. between the versions are compared to generate terminal version difference data. The version difference data includes the differences between the two in terms of functions, repair items, optimization points, etc. Through version number comparison and difference data extraction, the content required for the upgrade is clarified. For example, if a certain function is newly added in the upgrade package, the information of this function will be marked in the version difference data. If a certain repair item is missing in the current version of the terminal, the missing item will be clearly marked in the difference data. Finally, terminal version difference data is generated, and the items such as new functions added, vulnerabilities fixed, and performance optimized in the difference data are classified. For each type of difference, its impact on the terminal device is evaluated. For newly added functions,Confirm whether the device supports this function and estimate its resource requirements. For the content of fixing vulnerabilities, identify the affected modules and the vulnerabilities to be prioritized. For performance optimization, evaluate the performance bottlenecks of the terminal under the current version and generate targeted software upgrade requirements. The software upgrade requirements list contains specific operations for each difference, including which functions need to be activated, which modules need to be replaced, which patches need to be installed, etc. Based on this list, conduct a more detailed planning and resource allocation for the upgrade operations. Then, sort out the upgrade dependencies, analyze which upgrade tasks are interdependent and which tasks can be carried out in parallel. Through the dependency analysis, construct an upgrade dependency matrix, which clarifies the execution order of each task and the dependencies between them. The order between tasks ensures that dependent tasks can be carried out after the prerequisite tasks are completed. Based on the upgrade dependency matrix, start constructing an upgrade path map. The path map is a task execution roadmap drawn by analyzing the dependencies and order of each task in the matrix. Each path in the path map represents a task execution sequence, and the execution order and required resources of each task are marked on the path. During the construction of the map, use graphic algorithms such as topological sorting algorithms to ensure that the order of dependent tasks is reasonable. Tasks with clear dependencies are connected in the order of dependence. Each node on the path map represents an upgrade task, and the edge between nodes represents the dependency between tasks. After constructing the path map, based on this map, reorder the tasks in terms of time sequence. The purpose of time sequence reordering is to optimize the execution order of tasks according to the resource requirements, priorities and execution durations of tasks, ensure that tasks do not interfere with each other during execution and maximize resource utilization. After the time sequence adjustment, finally obtain the terminal software upgrade task list.

[0098] Preferably, step S2 includes the following steps:

[0099] Step S21: Evaluate the bandwidth requirements of the terminal software upgrade tasks to obtain the required bandwidth for the tasks; calculate the transmission limit for the required bandwidth of the tasks based on the preset terminal bandwidth data to generate a transmission rate limit;

[0100] Step S22: Allocate channels for the terminal software upgrade tasks according to the transmission rate limit to obtain a candidate multiplexing scheme;

[0101] Step S23: Traverse the dependencies between the terminal software upgrade tasks to obtain the task dependencies;

[0102] Step S24: Distinguish the independence of the terminal software upgrade tasks based on the task dependencies to generate independent software tasks and dependent software tasks.

[0103] In this embodiment, after obtaining the terminal software upgrade task, the bandwidth information required for each task is collected through the network interface of the terminal device. The bandwidth requirement of the task is estimated by analyzing the amount of data required for the task and the scheduled transmission time. First, the file size of each task is obtained, and the total number of bytes of the file is obtained by parsing the metadata of the upgrade package. Then, a preliminary calculation is performed based on the scheduled download time of the task. The bandwidth requirement is obtained by dividing the amount of data in the task by the transmission time. The bandwidth calculation formula is used, such as dividing the file size by the expected transmission time, to obtain the bandwidth required for each task. If the task includes multiple files, the bandwidth requirement is the sum of all file requirements. Next, the transmission limit calculation is performed based on the preset bandwidth data of the terminal device. The preset bandwidth data is configured by the device hardware. and the current network conditions. During the calculation process, if the bandwidth required for the task exceeds the network bandwidth of the terminal device, bandwidth limitation processing is performed. The transmission rate limit is adjusted according to the bandwidth upper limit of the terminal device and the priority of the task. If the bandwidth requirement is lower than the preset bandwidth, the task is guaranteed to be transmitted at the optimal rate. Finally, the transmission rate limit of each task is obtained. Channel allocation is performed based on the calculation result of the transmission rate limit of each task. First, the current available network resource information of the terminal device is obtained, including available bandwidth, number of channels, channel frequency band, etc. A channel allocation algorithm, such as a load minimization algorithm, is used to match the terminal software upgrade task with the channel. The channel allocation of each task is determined based on the transmission rate limit of each task and the available channel resources. When allocating channels, we consider the differences in bandwidth requirements between tasks and try to avoid allocating tasks with larger bandwidth requirements to the same channel to reduce conflicts and transmission delays. At the same time, the priority of tasks will also affect channel allocation. Tasks with higher priorities will be given priority to obtain more transmission bandwidth when bandwidth resources are limited. After the channel allocation is completed, a candidate multiplexing scheme will be obtained. The multiplexing scheme allocates different channels to different tasks or task groups, thereby achieving parallel transmission of multiple tasks. When traversing dependencies between tasks, first, we analyze the terminal software upgrade task list to identify the dependencies between tasks. The identification of dependencies is completed by parsing the module dependency data in the upgrade package. The upgrade package usually contains task execution order information. The information clearly indicates that some tasks must be executed before other tasks. The traversal of task dependencies starts from the starting point of the task, and the dependencies of each task are checked one by one to confirm the predecessor and successor tasks of the task. Through recursive traversal, the task dependency tree is gradually built. Each node in the task dependency tree represents a task, and the edges between nodes represent the dependencies between tasks. If task A depends on task B, then in the dependency tree, task A points to task B. During the dependency traversal process, each traversed task will be marked as processed or unprocessed. A processed task means that all its dependencies have been traversed and can be executed. An unprocessed task needs to wait for the dependent tasks to be completed before it can be executed. After the traversal is completed, a complete list of task dependencies is obtained.Based on the task dependencies obtained in the previous step, the independence of tasks is distinguished. First, by traversing the task dependency list, tasks are divided into independent tasks and dependent tasks. An independent task refers to a task on which no other task depends, and these tasks can be executed in parallel without any dependency conditions. A dependent task refers to a task for which at least one prerequisite task must be executed first before this task can be executed, and dependent tasks need to be executed sequentially according to the order of the dependency relationship. The distinction between independent tasks and dependent tasks is completed by analyzing the node relationships in the task dependency tree. If a task has no dependent tasks, it is an independent task; if a task depends on other tasks, it is a dependent task. After the distinction of tasks is completed, the independent tasks and dependent tasks are assigned to different task groups. The tasks within the independent task group can be executed in parallel, while the tasks within the dependent task group are executed sequentially. Finally, two groups of tasks are generated: the independent software task group and the dependent software task group.

[0104] Preferably, step S22 includes the following steps:

[0105] Estimate the channel resources for the terminal software upgrade task according to the transmission rate limit, and generate available channel data;

[0106] Identify the feasible transmission paths for the available channel data to obtain feasible path data; calculate the bandwidth allocation for the feasible path data to generate path bandwidth allocation data;

[0107] Conduct a concurrent channel limit analysis on the feasible path data based on the path bandwidth allocation data to obtain the maximum number of channels;

[0108] Perform parallel node partitioning according to the preset channel node level parameters and the maximum number of channels to generate a parallel node combination;

[0109] Allocate transmission channels for the parallel node combination to obtain channel allocation data; calculate the time division multiplexing ratio based on the channel allocation data to generate time division multiplexing data;

[0110] Conduct channel switching scheduling on the channel allocation data and the time division multiplexing data to generate channel switching timing data;

[0111] Integrate the data obtained from the above steps to obtain a candidate multiplexing scheme.

[0112] In this embodiment, the transmission rate limit information of the terminal software upgrade task is obtained. The transmission rate limit of each task represents the maximum bandwidth required by the task within a specified time. On this basis, channel resource estimation is performed on each task according to the hardware capabilities of the terminal device and the current network status. The channel resource estimation takes into account factors such as the physical bandwidth of the device, channel utilization, and network latency. Combining these factors, corresponding channel resources are allocated to each task. The resource estimation is implemented through the network resource management module. The specific operation is to use the transmission rate limit of the task and the network load situation to perform reasonable channel allocation for the task, ensuring that the bandwidth requirements of each task do not exceed the bearing capacity of the terminal device, and at the same time preventing bandwidth conflicts and overload situations between tasks. Finally, available channel data is generated, including the channel resource information and bandwidth allocation situation corresponding to each task. After obtaining the available channel data, based on the network topology structure, the transmission path of each task is identified. By analyzing each channel node and its connection relationship in the network topology, the feasible transmission paths of each task are identified. First, the source node and target node of each task are determined. According to the network connection situation of the terminal device, the available transmission channels are analyzed. The transmission path identification process is carried out through a network path planning algorithm. The algorithm analyzes the nodes and edges in the network topology and selects the optimal path as the feasible path of the task according to parameters such as bandwidth, latency, and stability between nodes. If there are multiple paths, the bandwidth and latency of each path are evaluated, and the path with a wider bandwidth and lower latency is selected. Finally, the feasible path data of each task is obtained, and the node information and connection quality of the feasible path are recorded. According to the identified feasible path data, bandwidth allocation calculation is performed. First, the bandwidth capacity of each feasible path is obtained. The bandwidth capacity is determined based on the maximum bearing bandwidth of each channel and the network load situation. Next, the bandwidth of each path is allocated. During the calculation process, the transmission rate limit of the task is used as the basis for bandwidth allocation. If multiple tasks share the same path, the path bandwidth is reasonably allocated to ensure that there are no conflicts in the bandwidth requirements between tasks. The bandwidth allocation algorithm adopts a fair allocation strategy and allocates the path bandwidth according to the priority and bandwidth requirements of the tasks. Tasks with higher priorities will obtain more bandwidth. If the bandwidth is insufficient, tasks with lower priorities will be delayed or allocated less bandwidth. After calculation, path bandwidth allocation data is generated, including the bandwidth allocation situation of each path. After completing the path bandwidth allocation, based on the path bandwidth allocation data, concurrent channel limit analysis is performed. The purpose of the analysis is to determine the maximum number of channels that can be transmitted in parallel under the given bandwidth limit. First, according to the bandwidth capacity and the allocated bandwidth of each path, the number of tasks that can be transmitted in parallel on each path is calculated. If the path bandwidth is large, more tasks can be processed in parallel at the same time. On the contrary, the number of parallel tasks is limited by the bandwidth. The channel capacity calculation model is used to evaluate the maximum number of tasks that can be carried on each feasible path for parallel execution.Channel limit analysis will consider the total bandwidth of each path and the bandwidth requirements of each task. According to the resource status of each path, the maximum number of channels is determined to obtain the maximum concurrent channel number of each path. Based on the level parameter of the channel node and the maximum number of channels, parallelizable node division is performed. The channel node level parameter is preset according to the node characteristics and load capacity in the network topology. The level of each node determines the transmission capacity and stability of the node. Nodes with a higher channel node level can carry more parallel tasks, while lower-level nodes need to limit the number of parallel tasks. Based on this level parameter, the feasible nodes of each path are divided. First, analyze the number of parallelizable channels on each path according to the maximum number of channels, and divide the nodes into multiple groups according to their levels. Nodes with a higher level will be assigned more parallel tasks, while lower-level nodes will be assigned fewer parallel tasks. After the division is completed, a parallelizable node combination is obtained. The nodes within each combination can carry multiple tasks simultaneously, and the tasks in the node combination are executed in parallel within the network load range. Finally, a parallelizable node combination is generated. According to the generated parallelizable node combination, transmission channel allocation is performed. First, obtain the bandwidth requirements of each node combination. By analyzing the bandwidth requirements of each task within the node combination, determine the total bandwidth required for each node combination. Then, according to the network bandwidth resource situation, perform channel resource allocation for each node combination. When allocating channels, consider the priority and bandwidth requirements of the node combination. Combinations with a higher priority will obtain more channel resources. During the channel allocation process, it is also necessary to avoid channel conflicts and bandwidth overload. After the allocation is completed, channel allocation data is obtained, recording the channel resource information and bandwidth usage situation allocated to each node combination. After the channel allocation is completed, based on the channel allocation data, the time division multiplexing ratio is calculated. The time division multiplexing ratio refers to the time interval ratio of task execution when multiple tasks are allocated on the same channel. By calculating the time division multiplexing ratio, the optimal time window for multiple tasks to alternate transmission on the channel can be determined. First, according to the transmission time requirements of each task and the bandwidth allocation situation of the channel, calculate the transmission time of each task, and calculate the time division multiplexing ratio based on the priority and time interval between tasks. If the transmission time between tasks is short, the tasks will be transmitted in parallel within the same time window. If the time interval is long, time scheduling is required. Finally, calculate the time division multiplexing ratio of each channel to generate time division multiplexing data. Based on the channel allocation data and the time division multiplexing data, channel switching scheduling is performed. First, by analyzing the transmission timing of tasks and the time division multiplexing ratio, determine the optimal transmission period of each task to ensure that the task is completed within its specified time window. When performing channel switching scheduling, consider the network load, bandwidth allocation, and priority of tasks, and dynamically adjust the transmission order of tasks to avoid conflicts and delays during channel switching. The channel switching order of tasks is reasonably arranged according to the time division multiplexing data and the channel allocation data to ensure that each task can be successfully completed within the scheduled time. Finally, generate channel switching timing data.Record the transmission order of tasks and the channel switching process. After completing all steps, integrate the data generated from channel resource estimation, feasible path identification, bandwidth allocation measurement, concurrent channel limit analysis, parallel node partitioning, transmission channel allocation, time-division multiplexing ratio calculation, and channel switching scheduling. The integration process is implemented by the multiplexing scheme management module. The module aggregates all the data based on the resource requirements, network bandwidth, and transmission timing information of each task to generate the final candidate multiplexing scheme. The candidate scheme will be optimized according to channel resource allocation, bandwidth limitations, latency requirements, and the number of concurrent tasks to finally determine the optimal multiplexing scheme.

[0113] Preferably, step S3 includes the following steps:

[0114] Step S31: Perform graph theory topological mapping on the dependent software tasks to obtain a task dependency graph;

[0115] Step S32: Perform a depth-first traversal detection on the task dependency graph to obtain a dependent task timing chain;

[0116] Step S33: Perform multi-channel feature mapping on the dependent task timing chain according to the candidate multiplexing scheme to obtain a head task processing matrix;

[0117] Step S34: Perform pipeline scheduling optimization on the dependent task timing chain based on the head task processing matrix to generate upgraded dependent tasks.

[0118] In this embodiment, the topological mapping of software task dependencies is performed using the Directed Acyclic Graph (DAG) model in graph theory. First, each task and its corresponding dependencies are identified. The dependencies are determined by the input-output relationships between tasks. If the output of task A is the input of task B, then task A depends on task B. The dependency graph is represented by the edges formed by tasks and their dependencies. The dependencies between tasks are modeled through graph theory algorithms. First, task nodes are established and directed edges are added to the nodes based on the dependencies between tasks to form a directed acyclic graph. Each node in the graph represents a task, and the direction of the edge represents the dependency relationship between tasks. The generated task dependency graph includes all tasks and the dependencies between tasks. Each node in the graph is marked with specific information about the task, such as task ID, bandwidth requirement, estimated time, etc. The construction of the graph is carried out through graph theory tools, such as network graph analysis tools, which perform topological sorting to ensure that there are no conflicts in the task execution order. Finally, a complete task dependency graph is obtained. After the task dependency graph is completed, a depth-first traversal is performed to analyze the timing chain of dependent tasks. The depth-first traversal starts from the starting task node of the task dependency graph and depth-first searches all dependent tasks along the edges in the graph. The execution order of tasks is identified through the traversal process. The dependent tasks are arranged in sequence according to the direction of the directed edges in the graph. During the traversal process, the start time and end time of each task are marked to ensure that each task is executed in the correct order. When performing the depth-first traversal, the parent task and child task of each node are recorded. After the traversal is completed, the timing chain of dependent tasks is obtained. Each task node in the timing chain is arranged in sequence to form a timeline for task execution. The depth-first traversal algorithm is carried out recursively, and the child tasks of each node can only start executing after the previous task has been completed. The finally generated timing chain includes the execution order of all tasks and their mutual dependencies. After the task dependency timing chain is generated, multi-channel feature mapping is performed according to the candidate multiplexing scheme. First, the channel allocation and bandwidth allocation in the candidate multiplexing scheme are analyzed. The channel characteristics provided by each candidate scheme, such as channel bandwidth, delay, etc., will affect the execution efficiency of tasks. Based on the information of these schemes, the tasks in the dependent task timing chain are mapped to different channels. Each task is assigned to an appropriate transmission channel according to its bandwidth requirement, transmission rate, and required time. During the mapping process, based on the dependency relationship of tasks, it is ensured that each task enters the execution state immediately after its dependent predecessor task is completed. The head task is usually the first task in the timing chain. On this basis, the processing time of each task is calculated and assigned to a suitable multi-channel for parallel processing. Using the multi-channel feature mapping algorithm, multiple tasks are parallelly assigned to different channels. Parameters such as the processing time, bandwidth requirement, and priority of tasks are used as the basis for mapping. Finally, a head task processing matrix is obtained. Each element in the matrix corresponds to the processing duration and transmission bandwidth of a certain task on a specified channel. Based on the head task processing matrix,Perform pipelining scheduling optimization for the dependent task timing chain. First, obtain information about each task node in the head task processing matrix, such as the start time, processing duration, required bandwidth, etc. of the task. Through this information, optimize the execution order of the tasks to enable parallel execution in a multi-channel environment. The optimization process is carried out through a scheduling algorithm. The goal of the scheduling algorithm is to reduce the waiting time and bandwidth conflicts between tasks, ensure that each task starts execution at an appropriate time, and utilize the parallelism of multiple channels to perform pipelining scheduling for adjacent tasks. Pipelining scheduling means that each task starts immediately after the previous task is completed, avoiding resource waste. During the scheduling process, according to the timing information of the head task processing matrix and the dependency relationships between tasks, arrange the execution time of the tasks so that the dependency relationships between tasks are satisfied, and at the same time optimize the use of transmission bandwidth. After the scheduling is completed, generate the final upgraded dependent tasks. The upgraded dependent tasks include all tasks and their optimized execution timings.,

[0119] Preferably, step S33 includes the following steps:

[0120] Perform multi-channel feature decomposition on the dependent task timing chain to obtain a task feature tensor; perform inter-channel coupling optimization on the task feature tensor to generate an optimized coupling matrix;

[0121] Perform sparse reconstruction on the optimized coupling matrix to generate a sparse feature mapping relationship; perform dynamic weight allocation according to the sparse feature mapping relationship to generate weight allocation data;

[0122] Perform multiplexing fusion processing on the weight allocation data to generate a fusion feature matrix; perform head task extraction on the fusion feature matrix to obtain a head task processing matrix.

[0123] In this embodiment, during the feature decomposition process relying on the task timing chain, first, feature extraction is performed on each task to extract the key parameters of the task, such as task type, bandwidth requirement, estimated execution time, etc. These parameters are organized in matrix form in chronological order, and the feature vector of each task includes numerical values in multiple dimensions, constituting a feature tensor. The feature tensor models the behavior of the task in a multi-dimensional space. Each dimension in the matrix represents a certain characteristic of the task, such as bandwidth requirement, resource consumption, etc. Through the tensor decomposition algorithm, the features of the task are decomposed into different channels, and each channel represents an independent characteristic of the task. During the decomposition process, the singular value decomposition (SVD) algorithm is used to reduce the dimension of the task features through SVD. Finally, the multi-dimensional features are assigned to multiple channels, so that each channel only processes a specific dimension of task characteristics. When optimizing the multi-channel feature tensor, first analyze the correlation of the task in different channels, apply the channel coupling optimization algorithm, and generate an optimized coupling matrix by maximizing the coupling degree between channels. During the coupling optimization process, use the common features to identify the similarity between tasks, generate a coupling matrix by calculating the mutual influence between different channels. Each element of the coupling matrix represents the degree of association of task features between different channels. Use the optimization algorithm to adjust the elements in the coupling matrix, reduce the redundant features between channels and enhance the connection between important features, and finally generate a highly optimized coupling matrix. During this process, the matrix decomposition algorithm (such as weighted least squares method) is used to minimize the coupling degree difference. Based on the optimized coupling matrix, use the sparsification reconstruction technology to process it. The goal of the sparsification process is to remove the redundant connections in the coupling matrix and only retain the important task coupling relationships. Use the sparse matrix algorithm (such as L1 regularization) to process the optimized coupling matrix, set the unnecessary coupling relationships to zero, so that the non-zero elements in the matrix only represent the important task dependencies. During the sparsification process, first calculate the influence degree of each channel on other channels, and remove the task dependencies with less influence by threshold screening of the matrix elements to obtain the sparse feature mapping relationship. When performing dynamic weight allocation according to the sparse feature mapping relationship, first analyze the weight information of each task in the sparse feature mapping relationship. Each non-zero element in the sparse matrix represents the degree of dependence between tasks. Therefore, the weight of the task can be determined according to the coupling degree of each task with other tasks. Use the weighting algorithm to adjust the weight of the task according to its position in the dependency chain, and preferentially assign high weights to those tasks with stronger dependencies. During the weight allocation process, use the adaptive optimization algorithm (such as genetic algorithm) to dynamically adjust the weight of each task, and adjust the weight of the task according to the priority of the task and resource limitations such as network bandwidth. When performing multiplexing fusion processing on the weight allocation data, first, according to the weight allocation information of the task, assign tasks with similar features or mutual dependencies to the same channel for parallel processing. The goal of the fusion processing is to synchronize and coordinate the execution processes of multiple tasks.By analyzing the execution timing, bandwidth requirements, and weight information of tasks, calculate the way for multiple tasks to share bandwidth and computing resources. Use a multiplexing algorithm to merge the transmission data of multiple tasks to minimize resource conflicts between tasks when executing on the same channel, and generate a fused feature matrix. The fused feature matrix records the bandwidth allocation and resource allocation strategies of each task on different channels. The transmission data of tasks is fused into different channels. The finally generated fused feature matrix has multiple dimensions, with each dimension corresponding to the transmission data of one channel. After the fused feature matrix is generated, head task extraction is performed. First, extract the first task in the task sequence from the fused feature matrix. This task is usually the key task in the entire software upgrade process, that is, the task to be executed with the highest priority. During the extraction process, identify the execution order of tasks from the fused matrix based on factors such as task priority, execution duration, and bandwidth requirements. The purpose of head task extraction is to determine which tasks should be executed first and ensure that these tasks can be completed in the shortest time. The extracted head task processing matrix includes the execution parameters of all primary tasks, such as task ID, required resources, and processing time, etc. Finally, the obtained head task processing matrix will guide the task execution arrangement in the entire software upgrade process.

[0124] Preferably, step S34 includes the following steps:

[0125] Extract features from the head task processing matrix to obtain head task features; perform pipeline mapping on the dependent task timing chain based on the head task features to obtain a dependent task pipeline;

[0126] Identify resource competition between tasks in the dependent task pipeline to obtain competing dependent tasks; perform deadlock detection on the dependent task pipeline based on the competing dependent tasks to generate conflicting dependent tasks;

[0127] Perform avoidance scheduling adjustment on the conflicting dependent tasks to obtain a conflict avoidance strategy; perform pipeline avoidance optimization on the dependent task timing chain according to the conflict avoidance strategy to generate an avoidance pipeline;

[0128] Identify resource sharing between tasks in the dependent task pipeline to generate cooperative dependent tasks; perform cooperative scheduling adjustment on the dependent task pipeline based on the cooperative dependent tasks to generate synchronous dependent tasks;

[0129] Perform pipeline optimized scheduling on the avoidance pipeline based on the synchronous dependent tasks to generate upgrade dependent tasks.

[0130] In this embodiment, the execution time, resource consumption and inter-task dependencies of each task are analyzed, and the tasks are characterized by feature engineering methods to extract the core feature data of each task, including the task ID, resource requirements, execution order, time window, etc. These features are formed into feature vectors, and each dimension in the matrix is ​​standardized to ensure that the numerical range of the features is within a unified standard. Subsequently, the principal component analysis (PCA) method is used to reduce the dimension of the feature matrix to extract the most representative task features and obtain the head task feature matrix. Each row in the matrix represents the features of a head task, and the elements in the row correspond to different characteristics of the task, such as the required bandwidth, computing time and priority, etc., which are then processed in the dependent task timing chain. In the process of pipeline mapping, the head task features are first sorted, and the execution order of tasks is arranged according to the task priority and execution time. According to the task priority and required resources in the head task feature matrix, the tasks in the dependent task timing chain are grouped, and tasks with similar features are assigned to the same pipeline. The task timing chain is divided through a graph-based algorithm (such as depth-first search DFS) to ensure that the tasks in each pipeline meet the constraints of execution order and resource requirements. The dependency relationship between tasks is considered in the mapping process, and the task dependency chain is adjusted to multiple pipelines. The tasks in the pipeline are arranged in order according to their execution time and dependency order to obtain the dependent task pipeline, and the tasks in the dependent task pipeline are sorted. When identifying resource competition between tasks, we first analyze the resources required by the tasks in each pipeline. Task resources can include computing resources, bandwidth, storage space, etc. We use a resource allocation model to predict the resource requirements of tasks. By comparing the resource requirements of tasks in the pipeline, we identify the task pairs with conflicting resource requirements. When resource competition occurs, since multiple tasks request the same resources or bandwidth at the same time, it is necessary to judge the resource competition between tasks. We associate tasks through the adjacency matrix model in graph theory, identify the resource competition dependencies between tasks, and generate a competition-dependent task dataset. Competition-dependent tasks are usually manifested as high demands for the same resources by multiple tasks in the same time period. When deadlock detection is performed on dependent task pipelines, we first detect Measure the resource competition relationship between tasks and construct a resource request graph. The nodes in the graph represent tasks, and the edges represent the resource dependency relationship between tasks. Use a deadlock detection algorithm (such as the resource allocation graph method) to track the resource dependency chain between tasks to determine whether there is a loop structure. If there is a circular resource request chain, it indicates that there is a deadlock risk between tasks. Generate a conflict-dependent task data set. Conflicting dependent tasks refer to tasks that cannot be executed simultaneously due to resource competition. Through further analysis of conflict-dependent tasks, the root cause of deadlock is identified. The possibility of deadlock usually occurs when tasks repeatedly request the same resources. After deadlock detection, all tasks that may cause deadlock will be marked. In the avoidance scheduling adjustment process of conflict-dependent tasks,First, identify the task pairs with resource competition, and re-schedule the conflicting tasks according to the priorities and resource requirements of the tasks to avoid resource competition at the same time. Adopt the task re-ordering technology to adjust the execution order of the tasks so that the tasks competing for resources are executed at intervals. By adopting the Earliest Deadline First (EDF) scheduling strategy, the high-priority tasks are executed in advance, and the low-priority tasks are postponed. During the adjustment process, combined with the resource consumption and timeliness requirements of the tasks, formulate a conflict avoidance strategy to ensure the reasonable allocation of resources so that the tasks can be executed in the expected order and priority. Finally, generate a conflict avoidance strategy, and adjust the task order in the dependency task time sequence chain according to the conflict avoidance strategy to ensure that the tasks are executed in priority order and avoid resource competition between tasks. During the optimization process, by simulating different task execution paths and scheduling strategies, select the optimal execution order so that there are no conflicts in the execution of tasks on each pipeline. By avoiding resource conflicts between high-priority tasks and low-priority tasks, optimize the execution efficiency of tasks. The pipeline avoidance optimization algorithm schedules tasks according to the resource requirements, dependencies, and execution durations of the tasks to ensure that the tasks in the pipeline are reasonably allocated resources, and finally generate an avoidance pipeline. During the process of identifying resource sharing between tasks, first analyze the resource requirements of the tasks to determine which tasks can share computing resources, bandwidth, or storage space. Adopt a resource sharing model to calculate the shared resource amount between each pair of tasks and identify those tasks that can be executed collaboratively. Resource sharing identification usually occurs when multiple tasks have a common demand for the same type of resource. By optimizing task allocation, identify cooperative dependent tasks that can share resources and execute simultaneously, thereby improving the execution efficiency of tasks. Based on the resource requirements and sharing situations between tasks, generate a set of cooperative dependent tasks. During the scheduling process of cooperative dependent tasks, first group the cooperative dependent tasks according to the resource sharing relationship between the tasks, and arrange the tasks that can be executed collaboratively in the same pipeline. By adjusting the task execution order, ensure that the cooperative dependent tasks can share the same resources and execute simultaneously. Adopt a task parallel scheduling strategy to ensure that there are no conflicts in the collaborative execution between tasks. Based on the resource requirement characteristics of the cooperative dependent tasks, adjust the execution time and order of the tasks in the pipeline so that the cooperative dependent tasks can be reasonably scheduled on resources, and finally generate synchronous dependent tasks. Based on the execution requirements of the synchronous dependent tasks, optimize the task order in the avoidance pipeline to ensure that resource conflicts can be avoided on the premise of collaborative execution between the synchronous dependent tasks. The optimization of the task order ensures that the tasks can be executed in the optimal time period by adjusting the execution time of the tasks. Adopt the Shortest Job First (SJF) scheduling strategy to make the short-time tasks execute first, thereby reducing the total execution time of the tasks, and finally realize the optimized scheduling of the pipeline and generate the final upgraded dependent tasks.

[0131] Preferably, step S4 includes the following steps:

[0132] Step S41: Perform time slot allocation simulation on the candidate multiplexing scheme to obtain task time-sharing scheduling data;

[0133] Step S42: Perform resource decoupling mapping on the independent software tasks according to the task time-sharing scheduling data to generate independent task priorities;

[0134] Step S43: Perform pipeline conversion on the independent software tasks based on the independent task priorities to obtain upgraded independent tasks;

[0135] Step S44: Perform concurrent scheduling optimization on the upgraded independent tasks and upgraded dependent tasks to obtain a resource scheduling strategy;

[0136] Step S45: Perform load balancing optimization on the resource scheduling strategy to generate an upgraded execution sequence.

[0137] In this embodiment, the task data of the candidate multiplexing scheme is obtained, the execution time, required bandwidth, and resource consumption of each task are analyzed, and they are sorted based on the priority of the tasks. A time window is assigned to each task, and the length of the time window is determined according to the execution requirements and resource constraints of the task. The Round Robin algorithm is used to allocate time slots for the tasks to ensure that the tasks do not overlap in time and the time window intervals of each task conform to the resource availability. During the task allocation process, it is ensured that each task is executed in the correct order according to the dependencies between tasks. After completing the time slot allocation simulation, the obtained task time-sharing scheduling data contains the execution time and allocated resources of each task. The data structure uses a two-dimensional array, where the first dimension represents the tasks and the second dimension represents the time slot information and resource allocation situation of the tasks. The resource requirements of each independent software task are analyzed to determine the independent resource requirements of each task, including CPU resources, memory, bandwidth, etc. Then, the resource consumption of each task in different time slots is decoupled, and the decoupling algorithm is used to independently process the resource requirements of each task to ensure that there are no resource conflicts between tasks. Multiple tasks are allocated to different processing units through the mapping strategy. The priority of the tasks is calculated based on the execution time and resource occupancy of the tasks. The priority is determined based on the Shortest Job First (SJF) algorithm for scheduling, and tasks with shorter execution times are executed first. The priority of independent tasks is evaluated by weighting the time slots allocated to the tasks. The evaluation criteria include the execution urgency of the tasks, the scarcity of the required resources, and the dependencies between tasks, generating a priority data set for independent tasks. The tasks are sorted according to the priority of independent tasks, and tasks with higher priorities are executed first. The sorted tasks are mapped according to the pipeline structure. The pipeline divides the tasks into several stages to ensure that the tasks within each stage can be executed in parallel. The tasks are executed within each stage according to the dependencies. The parallelism of the tasks is improved through the pipeline structure. The tasks in each pipeline stage must be independent and will not interfere with each other during execution. The resource requirements of the tasks have been split into multiple independent modules through the previous resource decoupling mapping to ensure that each module can work independently during execution. Through the pipeline scheduling algorithm, the pipeline is reasonably scheduled to ensure that each task is successfully completed within the specified time slot. Through the flow control and task scheduling strategy, the generation of resource bottlenecks is reduced, and finally, the upgraded independent tasks are obtained. According to the execution time and resource requirements of the upgraded independent tasks and upgraded dependent tasks, the tasks are allocated to different processing units for parallel execution. The parallel scheduling algorithm, such as the Maximum Parallelism Scheduling,The MPS algorithm minimizes the waiting time between tasks. It monitors the execution progress of tasks in real time through a dynamic scheduling algorithm and adjusts the execution order of tasks according to the real-time availability of resources. For tasks with high resource requirements, idle resources are preferentially allocated for processing, and the execution order of tasks is adjusted to avoid resource competition, ensuring that tasks can be executed in parallel without interfering with each other. During the optimization process, according to the priority and execution requirements of tasks, the concurrent execution ratio of tasks is dynamically adjusted, and finally a resource scheduling strategy is generated. This strategy clarifies the execution order of tasks, resource allocation, and the parallel execution mode of tasks. Load analysis is performed on each task execution unit in the resource scheduling strategy to evaluate the consumption of system resources by each task. The load level of a task is evaluated by analyzing the execution time, resource requirements, and resource occupancy rate of the task. The load balancing algorithm (such as the Weighted Round Robin algorithm) is used to reallocate resources to ensure that each processing unit in the system has a balanced load and there is no situation where a certain processing unit is overloaded or idle. By dynamically adjusting the execution period and resource allocation ratio of tasks, the utilization efficiency of system resources is optimized, making the execution of tasks more balanced, avoiding resource waste and overloading of processing units. During the load balancing optimization process, combined with the change of resource requirements of tasks, the execution strategy of tasks is adjusted to ensure that the resources of the system are best utilized without affecting the execution efficiency of tasks, and finally an upgraded execution sequence is generated.,

[0138] Preferably, step S43 includes the following steps:

[0139] Segment the execution stage of the independent software task based on the independent task priority to obtain a segmented task sequence; calculate the stage duration of the segmented task sequence to generate a stage duration matrix;

[0140] Identify the connection points according to the stage duration matrix to generate stage connection points; construct a task pipeline model based on the stage connection points;

[0141] Conduct parallel analysis on the task pipeline model to generate a task parallel structure; configure the buffer for the task parallel structure to obtain a buffer transfer area;

[0142] Schedule and optimize the independent software task according to the buffer transfer area to obtain an upgraded independent task.

[0143] In this embodiment, independent software tasks are sorted according to their priorities, and tasks with higher priorities are executed first. By analyzing the execution duration and resource requirements of the tasks, each independent software task is divided into several stages. The execution content of each stage is independent and can be processed in parallel. When segmenting, it is necessary to ensure that the execution logic and resource requirements of each stage do not conflict with each other. The connection relationship between each stage is determined through dependency analysis. According to the actual execution time of the tasks, the duration of each stage is calculated, and a stage segmentation structure is constructed to ensure that the execution of each task is reasonably split into stages, so that multiple tasks can be processed in parallel, improving the execution efficiency. The task segmentation method adopts the linear segmentation method. According to each stage in the segmented task sequence, the execution time of each stage is calculated based on the execution requirements of the task. The calculation method is to estimate the time of each stage using a time analysis model (such as a linear regression model) according to the resource requirements and historical execution data of the task. The execution time of each stage is input into the stage duration matrix. The stage duration matrix is a two-dimensional data table, where the first dimension represents the stage number of the task, and the second dimension represents the execution time of that stage. During the duration calculation, resource bottlenecks and conflicts between tasks encountered during task execution are considered. According to the stage duration matrices, the start time and end time of each stage are analyzed to find the overlapping areas between tasks. By identifying the connection points of the stage execution time, the connection points between stages are identified. The connection point refers to the time node where data exchange or resource switching is required between different stages. By sorting and analyzing the data in the duration matrix, the time connection points between each stage are determined. The time window analysis method is used to ensure that the setting of the connection point will not cause task execution delay by analyzing the execution gap between task stages. The identification of the connection point can be assisted by drawing the execution timing diagram of the task using a graphical tool (such as Matplotlib). Through the time sliding window (SlidingWindow) algorithm, the key connection points between each stage and the next stage are identified, and the stage connection point data is generated. Based on the stage connection points, the segmented task sequence is converted into multiple pipeline segments using the pipeline decomposition algorithm. Pipeline decomposition needs to ensure that the connection points between stages are not interrupted according to the execution logic and dependency relationship of each stage, and reasonably arrange the execution order of tasks in the pipeline. Through parallelism analysis, multiple tasks are assigned to different pipeline stages while avoiding resource competition and bottlenecks. During the decomposition process, considering the parallel execution ability of different stages, tasks are assigned to the pipeline segments with the optimal resources to generate a complete task pipeline model. Each stage in the model has clear input, output, and time control. After the task pipeline model is constructed, parallel analysis is performed to analyze the parallelism of each stage during execution, calculate the performance bottleneck of each stage during parallel execution, and identify the stages with lower parallelism in the pipeline.Use a parallelism optimization algorithm (such as the maximum parallelism analysis method) to evaluate the performance of the pipeline, identify task groups that can be executed in parallel, and allocate these task groups to multiple processing units to ensure efficient execution of each stage. For stages with insufficient resources, dynamically adjust the resource allocation. Generate a task parallel structure through parallel analysis. The task parallel structure describes how each stage runs in parallel on different execution units to maximize the task execution efficiency. Configure the buffers in the task parallel structure. First, evaluate the data transfer requirements of each stage to ensure that data transfer between each stage does not cause data congestion. Use a buffer configuration algorithm to set appropriate buffers between each task stage. The size of the buffer is calculated based on the task data volume and transfer rate to ensure that during parallel execution, the buffer can effectively store data and ensure smooth data transfer. After buffer configuration, generate buffer transfer area data. The buffer transfer area is used to temporarily store and transfer data during task execution to avoid data loss or delay. Based on the buffer transfer area, optimize the task scheduling, adjust the timing of task execution to ensure that tasks can start execution at the appropriate moment, and avoid conflicts between tasks due to insufficient buffers or resource competition. During the optimization process, adjust the execution order of tasks according to the priority and resource requirements of the tasks to ensure that each task can complete task execution within the specified buffer size range. Use a dynamic scheduling algorithm to adjust task execution to generate upgraded independent tasks. These tasks can complete execution in the shortest time after scheduling optimization, while ensuring smooth data transfer between tasks and efficient utilization of resources.

[0144] The present invention also provides a software upgrade system for an Internet of Things terminal, which is used to execute the software upgrade method for the Internet of Things terminal as described above. The software upgrade system for the Internet of Things terminal includes:

[0145] A version verification module, which is used to obtain software upgrade package information and terminal operation data; perform version verification on the terminal operation data and the software upgrade package to obtain terminal version difference data; perform sequential task sorting on the software upgrade package information based on the terminal version difference data to obtain a terminal software upgrade task;

[0146] A task allocation module, which is used to perform channel allocation on the terminal software upgrade task to obtain a candidate multiplexing scheme; distinguish the task independence of the terminal software upgrade task to generate independent software tasks and dependent software tasks;

[0147] A dependency sorting module, which is used to perform chain sorting on the dependent software tasks to obtain a dependent task time sequence chain; perform head task upgrade processing on the dependent task time sequence chain based on the candidate multiplexing scheme, and at the same time perform subsequent task upgrade preloading on the dependent task time sequence chain to generate upgraded dependent tasks;

[0148] A parallel scheduling module is used to perform parallel upgrade processing on independent software tasks based on candidate multiplexing schemes to generate upgraded independent tasks, and perform parallel scheduling on upgrade-dependent tasks and upgraded independent tasks to implement an intelligent software upgrade method for IoT terminals.

[0149] Through the implementation of the version verification module, the present invention ensures the matching of software upgrade packages and terminal operation data, avoiding upgrade failures caused by inconsistent versions. The design of the task allocation module optimizes the channel utilization rate and improves the data transmission efficiency. The clear distinction between independent software tasks and dependent software tasks provides a basis for subsequent parallel processing. The chain sorting mechanism of the dependency sorting module enhances the sequentiality of task execution, ensuring that the dependency relationships between tasks are reasonably processed. The priority upgrade of the head task and the preloading of subsequent tasks effectively reduce the overall upgrade time. The parallel scheduling of dependent tasks and independent tasks realizes the optimal utilization of resources, greatly improving the software upgrade efficiency. The intelligent design of the entire system makes the upgrade process more flexible and adaptable, capable of dynamically responding to different network environments and device states, and ultimately achieving efficient and stable software upgrade for IoT terminals.

[0150] Therefore, in any regard, the embodiments should be regarded as exemplary and non-limiting. The scope of the present invention is defined by the appended claims rather than the above description. Thus, all changes falling within the meaning and scope of the equivalent elements of the application documents are intended to be encompassed within the present invention.

[0151] The above are only specific embodiments of the present invention, enabling those skilled in the art to understand or implement the present invention. Various modifications to these embodiments will be obvious to those skilled in the art. The general principles defined herein can be implemented in other embodiments without departing from the spirit or scope of the present invention. Therefore, the present invention will not be limited to these embodiments shown herein, but rather to the broadest scope consistent with the principles and novel features disclosed herein.

Claims

1. A software upgrade method for an Internet of Things terminal, characterized in that: The following steps are involved: Step S1: Obtain software upgrade package information and terminal operation data; Perform version verification on the terminal operation data and the software upgrade package to obtain terminal version difference data; perform time sequence task sorting on the software upgrade package information based on the terminal version difference data to obtain the terminal software upgrade task; Step S2: performing channel allocation for the terminal software upgrade task to obtain a candidate multiplexing scheme; performing task independence distinction for the terminal software upgrade task to generate an independent software task and a dependent software task; Step S3: chain-sort the dependent software tasks to obtain a dependent task timing chain; perform head task upgrade processing on the dependent task timing chain based on the candidate multiplexing scheme, and perform subsequent task upgrade preloading on the dependent task timing chain to generate an upgraded dependent task; Step S4: Perform parallel upgrade processing on independent software tasks based on the candidate multiplexing scheme to generate upgrade independent tasks; perform parallel scheduling on upgrade dependent tasks and upgrade independent tasks to implement the intelligent software upgrade method for the Internet of Things terminal.

2. The method for upgrading the software of the Internet of Things terminal according to claim 1, characterized in that: Step S1 includes the following steps: Step S11: Obtain software upgrade package information and terminal operation data; perform software version identification on the terminal operation data to obtain a terminal software version identifier; Step S12: verifying the digital signature of the software upgrade package to obtain a credibility index of the upgrade package; extracting the version number of the software upgrade package information according to the credibility index of the upgrade package to generate a version identifier of the upgrade package; Step S13: performing version matching verification on the terminal software version identifier and the level package version identifier to obtain terminal version difference data; Step S14: Analyze the upgrade requirements based on the terminal version difference data to obtain the software upgrade requirements; sort out the upgrade dependencies of the software upgrade requirements to generate an upgrade dependency matrix; Step S15: construct a path map for the software upgrade package information according to the upgrade dependency matrix to obtain an upgrade path map; and rearrange the task sequence based on the upgrade path map to obtain a terminal software upgrade task.

3. The method for upgrading the software of the Internet of Things terminal according to claim 1, characterized in that: Step S2 includes the following steps: Step S21: performing bandwidth demand assessment on the terminal software upgrade task to obtain the bandwidth required for the task; performing transmission limit calculation on the bandwidth required for the task based on preset terminal bandwidth data to generate a transmission rate limit; Step S22: performing channel allocation for the terminal software upgrade task according to the transmission rate limit to obtain a candidate multiplexing scheme; Step S23: traverse the inter-task dependencies of the terminal software upgrade task to obtain the task dependency relationship; Step S24: distinguishing the independence of the terminal software upgrade tasks based on the task dependency relationship to generate independent software tasks and dependent software tasks.

4. The method for upgrading the software of the Internet of Things terminal according to claim 3, characterized in that: Step S22 includes the following steps: Estimating channel resources for the terminal software upgrade task according to the transmission rate limit and generating available channel data; Identify feasible transmission paths for available channel data to obtain feasible path data; calculate bandwidth allocation for feasible path data to generate path bandwidth allocation data; Based on the path bandwidth allocation data, the feasible path data is analyzed for concurrent channel limits to obtain the maximum number of channels; According to the preset channel node level parameters and the maximum number of channels, parallel nodes are divided to generate parallel node combinations; Allocate transmission channels for the parallel node combination to obtain channel allocation data; calculate the time multiplexing ratio based on the channel allocation data to generate time division multiplexing data; Perform channel switching scheduling on the channel allocation data and the time division multiplexing data to generate channel switching timing data; Integrate the data obtained in the above steps to obtain candidate multiplexing schemes.

5. The method for upgrading the software of the Internet of Things terminal according to claim 1, characterized in that: Step S3 includes the following steps: Step S31: Perform graph-theoretic topological mapping on dependent software tasks to obtain a task dependency graph; Step S32: perform deep traversal detection on the task dependency graph to obtain the dependent task timing chain; Step S33: performing multi-channel feature mapping on the dependent task timing chain according to the candidate multiplexing scheme to obtain a head task processing matrix; Step S34: Optimize the pipeline scheduling of the dependent task timing chain based on the head task processing matrix to generate an upgrade dependent task.

6. The method for upgrading the software of the Internet of Things terminal according to claim 5, characterized in that: Step S33 includes the following steps: Perform multi-channel feature decomposition on the dependent task timing chain to obtain the task feature tensor; optimize the inter-channel coupling of the task feature tensor to generate an optimized coupling matrix; The optimized coupling matrix is ​​sparsely reconstructed to generate a sparse feature mapping relationship; dynamic weight allocation is performed according to the sparse feature mapping relationship to generate weight allocation data; The weight distribution data is multiplexed and fused to generate a fused feature matrix; the head task is extracted from the fused feature matrix to obtain a head task processing matrix.

7. The method for upgrading the software of the Internet of Things terminal according to claim 5, characterized in that: Step S34 includes the following steps: Extract features from the head task processing matrix to obtain head task features; perform pipeline mapping on the dependent task timing chain based on the head task features to obtain the dependent task pipeline; Identify resource competition between tasks in the dependent task pipeline to obtain competing dependent tasks; perform deadlock detection on the dependent task pipeline based on the competing dependent tasks to generate conflicting dependent tasks; Perform avoidance scheduling adjustment on conflict-dependent tasks to obtain a conflict avoidance strategy; perform pipeline avoidance optimization on the timing chain of dependent tasks according to the conflict avoidance strategy to generate an avoidance pipeline; Identify resource sharing between tasks in dependent task pipelines and generate cooperative dependent tasks; perform cooperative scheduling adjustments based on the dependent task pipelines of cooperative dependent task teams and generate synchronous dependent tasks; The avoidance pipeline is optimized and scheduled based on the synchronization dependent tasks to generate upgrade dependent tasks.

8. The method for upgrading the software of the Internet of Things terminal according to claim 1, characterized in that: Step S4 includes the following steps: Step S41: simulating the time slot allocation of the candidate multiplexing scheme to obtain task time-sharing scheduling data; Step S42: performing resource decoupling mapping on independent software tasks according to task time-sharing scheduling data, and generating independent task priorities; Step S43: performing pipeline conversion on the independent software task based on the independent task priority to obtain an upgraded independent task; Step S44: performing concurrent scheduling optimization on the upgrade independent tasks and the upgrade dependent tasks to obtain a resource scheduling strategy; Step S45: Perform load balancing optimization on the resource scheduling strategy and generate an upgrade execution sequence.

9. The method for upgrading the software of the Internet of Things terminal according to claim 8, characterized in that: Step S43 includes the following steps: Based on the priority of independent tasks, the independent software tasks are segmented into execution phases to obtain a segmented task sequence; the phase time consumption of the segmented task sequence is calculated to generate a phase time consumption matrix; According to the time-consuming matrix of each stage, the connection points are identified to generate the stage connection points; based on the stage connection points, the pipeline is deconstructed and constructed to generate the task pipeline model; Perform parallel analysis on the task pipeline model to generate a task parallel structure; configure the buffer zone on the task parallel structure to obtain a buffer flow area; Independent software tasks are scheduled and optimized according to the buffer flow area to obtain upgraded independent tasks.

10. A software upgrade system for an Internet of Things terminal, characterized in that: The method for upgrading the software of the Internet of Things terminal according to claim 1 is used to implement the software upgrading method of the Internet of Things terminal, and the software upgrading system of the Internet of Things terminal comprises: The version verification module is used to obtain software upgrade package information and terminal operation data; perform version verification on the terminal operation data and the software upgrade package to obtain terminal version difference data; and perform time sequence task sorting on the software upgrade package information based on the terminal version difference data to obtain the terminal software upgrade task; The task allocation module is used to allocate channels for terminal software upgrade tasks to obtain candidate multiplexing schemes; distinguish the task independence of terminal software upgrade tasks to generate independent software tasks and dependent software tasks; The dependency sorting module is used to perform chain sorting on dependent software tasks to obtain a dependent task timing chain; perform head task upgrade processing on the dependent task timing chain based on a candidate multiplexing scheme, and perform subsequent task upgrade preloading on the dependent task timing chain to generate an upgraded dependent task; The parallel scheduling module is used to perform parallel upgrade processing on independent software tasks based on candidate multiplexing schemes to generate upgrade independent tasks; and to perform parallel scheduling on upgrade dependent tasks and upgrade independent tasks to realize an intelligent software upgrade method for IoT terminals.

Images