Method for standby power consumption of intelligent control system

Abstract

The application discloses a method for standby power consumption of an intelligent control system, and particularly relates to the technical field of mobile terminal power consumption control. Complete task metadata is generated when a task is submitted, and wake-up energy consumption estimation and instant reputation are calculated in parallel to serve as a feedforward basis before scheduling. Historical failure rate and delay samples are fused in scheduling decision, time-sensitive integrity and certificate availability are quantified and mapped into alignment coordination indexes to correct priority. During execution, segmented operation is performed according to a budget, and execution context and priority recovery marks are persistently saved when interrupted. After the completion of a task, a reputation image is constructed based on the difference between a declaration and actual consumption, and is used for adaptive quota adjustment. The number of invalid wake-up times is significantly reduced, the success rate is improved, safety verification is taken into account, and the method is applicable to multi-source concurrent and limited energy scenes. A cooperative mechanism of feedforward perception, access verification and post-reputation closed loop is formed, and the problem of standby power consumption rising caused by cross-priority dependence disorder is solved.

Description

Technical Field

[0001] This invention relates to the field of mobile terminal power consumption control technology, and more specifically, to a method for controlling the standby power consumption of an intelligent control system. Background Technology

[0002] Existing standby power consumption optimization task scheduling typically employs a priority- and time-limit-based time-slot processing approach: within each wake-up cycle, several priority time slots are pre-allocated, executing tasks marked as high priority first, followed by tasks with normal priority; simultaneously, to ensure timeliness, a maximum allowable delay for tasks is introduced to trigger forced wake-ups. To reduce wake-up frequency and overall power consumption, batch merging, delayed scheduling, and priority sorting are commonly used as primary methods, with declarative parameters (such as priority and maximum delay) guiding scheduling decisions when tasks are submitted. These methods assume that tasks are independent or that the application honestly declares resource and timeliness requirements, and that dependencies can be pre-configured statically using a fixed directed graph.

[0003] However, the above approach has several shortcomings in practical applications. First, there are often implicit time dependencies between background tasks, such as the dependency between credential refresh and incremental synchronization. If a high-priority task fails or is delayed, subsequent ordinary tasks will inevitably fail due to the lack of preconditions, leading to intermittent failures that are difficult to locate. Second, in open ecosystems, some applications may abuse high-priority or extremely short-delay declarations to compete for wake-up opportunities, undermining energy consumption optimization and increasing peak power consumption. Third, a single priority-based or remaining-delay-based processing strategy cannot simultaneously consider the importance and urgency of tasks, causing urgent but non-critical tasks to preempt resources and affect critical business operations. In addition, long-running tasks in high-priority categories may occupy wake-up cycles, causing ordinary tasks to fail and amplifying the global wake-up duration and energy consumption. Existing technologies lack comprehensive and implementable feedforward perception and closed-loop reputation adjustment mechanisms to address the aforementioned issues of cross-priority dependencies, declaration abuse, contradictions between importance and urgency, and long-task blocking, making it difficult to achieve substantial optimization of standby power consumption while ensuring functional reliability. Summary of the Invention

[0004] To overcome the aforementioned deficiencies in the prior art, this invention provides a method for standby power consumption in an intelligent control system. This method generates task metadata for the task submission phase and estimates wake-up energy consumption and reputation. It quantifies time sensitivity and credential availability based on historical failure rates and latency samples, maps, aligns, coordinates, and corrects priorities, allows for admission or suspension of tasks, executes tasks in segments according to budget, saves interruption context and priority recovery flags, constructs a reputation profile based on the discrepancy between claimed and actual consumption, and adaptively adjusts resource quotas to address the problems mentioned in the background art.

[0005] To achieve the above objectives, the present invention provides the following technical solution: a method for standby power consumption of an intelligent control system, comprising:

[0006] S1 Task Submission Steps: When submitting a task, generate a task metadata record for each task, which includes static priority, maximum allowed delay, and a list of dependent tasks, and store it in the task queue.

[0007] S2 Dynamic Priority Calculation Steps: At the scheduling decision point, calculate the dynamic priority score for the tasks in the queue based on the task metadata and the current time; the dynamic priority score is obtained by weighting the static priority with a preset weight.

[0008] S3 Dependency Verification and Scheduling Steps: Candidate tasks are filtered according to dynamic priority scores, and dependency verification is performed to determine whether a task should be allowed, suspended, or an error callback should be triggered.

[0009] S4 Controlled Execution Steps: During the wake-up window, a controlled execution context is created for the verified task, and the task is suspended with a recovery tag when the run quota is reached or the interruption condition is triggered.

[0010] S5 reputation feedback steps: Record task execution results and resource consumption, generate reputation records, and adjust task resource allocation based on these records during subsequent policy refreshes.

[0011] Preferably, the static priority acquisition method includes:

[0012] Receive a task request and generate a task metadata record; calculate the estimated wake-up energy consumption and real-time reputation score based on the task metadata record; generate a static priority based on the estimated wake-up energy consumption and the real-time reputation score.

[0013] The wake-up energy consumption estimate is obtained by calculating the resource requirements declared in the task and the unit power consumption model of the device, wherein the wake-up energy consumption estimate = Σ (resource requirements × corresponding resource power consumption coefficient); the instant reputation score is obtained by calculating the resource accuracy index and latency reliability index based on the task's historical execution records, wherein the instant reputation score is the weighted average of the resource accuracy index and latency reliability index; and the static priority is calculated by the following formula: static priority = γ × (1 - normalized energy consumption estimate) + δ × instant reputation score.

[0014] Preferably, the dynamic priority score is obtained in the following way:

[0015] The time sensitivity integrity index and the credential availability index are input as two input variables into the predefined mapping model. The alignment and coordination index output by the mapping is used to indicate the matching level between time sensitivity and security availability. When the alignment and coordination index is lower than the preset threshold, a priority correction operation is performed.

[0016] Priority adjustment refers to the weighted adjustment of static priorities. The weighting direction is automatically determined based on the trend of the alignment and coordination index to ensure that tasks are scheduled and executed first in high-risk or high-time-sensitivity scenarios, while tasks can be delayed in low-risk and low-sensitivity scenarios.

[0017] The corrected dynamic priority score is directly used as the basis for subsequent task scheduling and power consumption control, thereby achieving adaptive matching between task execution order and energy consumption status.

[0018] The generation process of the time-sensitive integrity index includes: extracting the historical failure rate time series from the task execution state memory, performing trend extraction and smoothing operations within a sliding window to obtain the delay sensitivity component; calculating the remaining delayable time based on the task schedule deadline and the current execution time, and estimating the delay sample variance by combining real-time collected delay samples to obtain the time vulnerability component; inputting the delay sensitivity component and the time vulnerability component into a nonlinear fusion function for mapping operations, and outputting the time-sensitive integrity index.

[0019] The calculation process of the voucher availability index includes: counting the number of successful and failed voucher updates in the recent task cycles from the voucher update records, and calculating the voucher update success rate component; extracting the delay time distribution characteristics from the recorded update delay samples, and estimating the update delay trend in the near future through a prediction method; calculating the risk weighting value based on the predicted delay and the remaining valid time of the current voucher, and merging the success rate component and the risk weighting value according to a preset ratio to obtain the voucher availability index.

[0020] Preferably, the availability status of the voucher is modeled as a state machine that includes valid, near-expiration, and invalid states; state transitions are driven by responding to voucher update events, and the voucher availability index is obtained by looking up a table based on the current state and the remaining validity time.

[0021] Preferably, the execution control process for the verified task in step S3 includes:

[0022] The execution budget allocated in the current wake-up cycle is used as a constraint, and a controlled context manager is used for quota scheduling. The execution budget is measured in units of processor available time slices or energy consumption limits, and the execution quota is calculated based on the current remaining energy E and task priority p. The execution quota is determined in the following way: based on the current system's available energy budget and the task's dynamic priority score, it is allocated proportionally according to the priority weight, and the allocated energy value is converted into the corresponding processor execution time as the execution quota for the task.

[0023] Before each segment is executed, record the progress pointer, local variable status, and list of incomplete operations for the current task;

[0024] When the remaining budget quota is detected to be lower than the preset threshold ε, an interrupt operation is triggered, the progress pointer and local state are written to non-volatile storage medium to form a suspended execution context, and a timestamp and progress tag are attached.

[0025] Write a priority recovery label in the suspended context. The weight P of the priority recovery label is calculated by multiplying and adding the dependency urgency level u and the incomplete proportion r with predefined weights.

[0026] When the scheduler scans the task queue, it prioritizes waking up tasks with high weight P.

[0027] Preferably, the dependency verification process in step S3 includes dependency task completion time prediction based on a prediction model, and the prediction model is obtained in the following ways:

[0028] Historical execution data of dependent tasks are collected, including planned execution time, actual execution time, system load, and hardware resource utilization. Data preprocessing is performed, including outlier filtering and data normalization. A Long Short-Term Memory (LSTM) network is used as the basic model structure. A frequency domain supervision mechanism is introduced during training: the predicted time-series data output by the model and the actual training label time-series data are converted to frequency domain data respectively. The difference between the two is calculated to construct a frequency domain loss function, which, together with the time-domain prediction loss function, guides model training. The trained model is encapsulated into a prediction function library, which receives metadata of dependent tasks and the current system state as input, and outputs the predicted time point and confidence interval for the task completion.

[0029] Preferably, the controlled execution step S4 specifically includes:

[0030] When the window is opened, a wake-up token is generated by the communication and system layer and managed by the kernel-mode token custodian.

[0031] The token is forcibly reclaimed at the window boundary, and any hold-on wake-up not released before the boundary is released when the token expires;

[0032] Requests added during the window period that do not meet the timeliness level are written to the subsequent queue.

[0033] Preferably, step S5, reputation feedback, specifically includes:

[0034] The actual resource consumption recorded during task execution is compared with the resource consumption declared when the task is submitted to generate a resource consumption deviation vector.

[0035] Based on the resource consumption deviation vector, calculate the task resource accuracy index and latency reliability index to form a task reputation profile;

[0036] During the policy refresh cycle, the policy engine generates correction instructions for queue sorting, priority guarantee identifiers, and execution budget allocation weights based on the task reputation profile, available execution budget, and dynamic task priority.

[0037] Preferably, the dependency verification and scheduling steps are followed by an alignment window scheduling step, specifically including:

[0038] Establish a wake-up source event queue (the original signal or request that can trigger the device to wake up from standby state), and write the source type, timeliness level and location requirement identifier for each event in the queue;

[0039] Based on the motion state tags provided by the perception layer and the positioning result cache provided by the data layer, the events in the wake-up source event queue are merged and deduplicated to generate a merged batch list.

[0040] Calculate the cluster wake-up coupling index and the location availability uncertainty index; input the cluster wake-up coupling index and the location availability uncertainty index into a predefined window priority coefficient model, and obtain the window priority coefficient through linear weighting; the weights are set based on the actual situation.

[0041] Based on the window priority coefficient, determine the window mapping offset and task merging depth of the current alignment window;

[0042] Based on the merged batch list and the location availability uncertainty index, a location strategy decision is made: if and only if there are candidate items in the list that indicate high timeliness location needs, and the location availability uncertainty index exceeds a preset threshold, real-time location is enabled within the current alignment window; otherwise, cached location results are sent.

[0043] Within the opened alignment window, batch processing is performed based on the system resource mapping, merging the operations of multiple tasks into a single power-on transaction; when the window closes, an execution summary is generated and the next cycle window parameters are updated based on the policy adjustment factor, subsequently triggering the system to enter a hibernation state.

[0044] Preferably, the calculation of the cluster wake-up coupling index includes:

[0045] The timestamp sequence in the wake-up source event queue is burst-segmented to form at least one burst cluster;

[0046] For each burst cluster, the sequence of event source types is regarded as the first random variable, and the time triggering order index of the event within the cluster is regarded as the second random variable;

[0047] By statistically analyzing the joint occurrence frequency of the first and second random variables, their joint probability distribution and their respective marginal probability distributions are estimated.

[0048] Calculate the actual mutual information value between the first random variable and the second random variable according to the mutual information formula;

[0049] Generate randomized control sequences that maintain the marginal occurrence rate of each source type and calculate their control mutual information values;

[0050] Calculate the ratio of the actual mutual information value to the control mutual information value, and take the natural logarithm of the ratio to output the cluster wake-up coupling index.

[0051] Preferably, calculating the location availability uncertainty index includes:

[0052] Based on the motion status label, the time staleness of the location result cache, and the type of location source, the confidence decay term of the cached location is calculated through the confidence decay model and used as the prior probability.

[0053] The number of newly added nodes in the surrounding wireless network environment per unit time is obtained as external observation evidence;

[0054] The prior probability is fused with external observation evidence using the Bayesian update formula to obtain the posterior probability.

[0055] The difference between 1 and the posterior probability is output as the location availability uncertainty index.

[0056] Preferably, performing batch processing within the alignment window includes:

[0057] The execution progress is monitored by the batch end trimmer window. When the preset time limit is reached before the window is closed, non-urgent operations are forcibly suspended and the associated wake-up records are released.

[0058] Execution requests added during the window period that do not meet the high timeliness level are written into the wake-up source event queue of the subsequent cycle.

[0059] The above description has eliminated the executing entity and uses standard actions such as "establish, calculate, input, determine, and execute" for description.

[0060] The technical effects and advantages of this invention are as follows:

[0061] (1) This invention generates and audits task metadata during the task submission phase, and calculates the wake-up energy consumption prediction index and the instant reputation index in parallel. Before scheduling, it calculates the time sensitivity integrity index and the credential availability index based on the historical failure rate and delay sample of the execution status record table. It further maps the alignment coordination index and corrects it to the dynamic priority score. This enables the quantification of time sensitivity and credential availability for sorting and admission decisions before wake-up, avoiding unnecessary wake-up and failure retries caused by unavailable credentials or timeliness conflicts. It effectively solves the problem of cross-priority dependency disorder and the resulting increase in standby energy consumption.

[0062] (2) This invention runs in segments according to execution quotas during the execution phase, writes the progress pointer and local state into the persistent context table when interrupted, writes the priority recovery tag, and calculates the resource accuracy index, latency reliability index and comprehensive task reputation profile based on the deviation vector between the declared value and the actual consumption value after the task is completed. This forms a collaborative mechanism of feedforward perception, access verification and post-event reputation closed loop, which effectively solves the problems of frequent wake-ups and low success rate caused by long task blocking and inaccurate resource prediction. Attached Figure Description

[0063] Figure 1 This is a simplified flowchart of the standby power consumption method of the intelligent control system of the present invention.

[0064] Figure 2 This is a flowchart of the wake-up source event alignment window of the present invention. Detailed Implementation

[0065] Exemplary embodiments of the present disclosure will now be described in more detail with reference to the accompanying drawings. While exemplary embodiments of the present disclosure are shown in the drawings, it should be understood that the present disclosure may be implemented in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of the disclosure to those skilled in the art.

[0066] At the same time, it should be understood that, for ease of description, the dimensions of the various parts shown in the accompanying drawings are not drawn according to actual scale.

[0067] The following description of at least one exemplary embodiment is merely illustrative and is in no way intended to limit the scope of this application and its application or use.

[0068] Techniques, methods, and equipment known to those skilled in the art may not be discussed in detail, but where appropriate, such techniques, methods, and equipment should be considered part of the specification.

[0069] First, the intelligent control system described in this invention refers to a comprehensive control system based on a mobile terminal, composed of hardware and software collaboration, and optimized for power consumption during standby. It includes at least: 1. A perception layer, consisting of sensing units for collecting device motion and attitude information, such as accelerometers and gyroscopes, and providing the upper layer with features required for basic filtering and state determination; 2. A positioning layer, containing a satellite positioning module and a cache management mechanism for positioning results, capable of switching between "real-time positioning" and "cached positioning" based on the device's motion state; 3. A communication and system layer, including an operating system kernel and power management framework, task scheduling and timer mechanisms, and application keep-alive mechanisms. The system, along with its background execution mechanism and associated communication subsystems such as cellular, Wi-Fi, and Bluetooth, supports unified reception, queuing, and scheduling of wake-up requests from applications. Fourth, the policy and governance layer includes policy engines such as dynamic wake-up alignment windows, periodic wakelock holding scans, whitelist exemptions, and anomaly cleanup. These engines are used to merge wake-up sources, suppress invalid background activities, and reduce the impact of location and power-lock mechanisms on standby power consumption without affecting critical business operations and system availability. Fifth, the data and configuration layer includes the storage, logging, and metric feedback of policy parameters and application lists to support online adaptive and long-term optimization of policies. This system is designed for network standby scenarios of mobile terminals such as smartphones and tablets. By uniformly monitoring and orchestrating three typical power consumption factors—wake-up, location, and power-lock—it achieves power consumption management and improved battery life in standby mode. The following system refers to the intelligent control system.

[0070] Example 1, see Figure 1 A simplified flowchart of a method for reducing standby power consumption in an intelligent control system is provided in this invention. Figure 1 The method for reducing standby power consumption in an intelligent control system, as shown, includes the following steps:

[0071] S1 Task Submission Steps: When receiving a task submitted by an application, construct a task metadata record. The task metadata includes fields such as task identifier, normalized basic priority, declared maximum allowable delay, list of dependent tasks, execution strategy identifier, submission timestamp, and declared resource consumption. Write the task metadata into the task queue list within a single transaction context. Based on local wake-up logs, historical execution records, and credential update records.

[0072] Step S1 Summary: Within the standby power consumption optimization framework of the intelligent control system, the initial task registration stage determines the energy efficiency and success rate of the entire subsequent scheduling chain. This step occurs the instant the application submits a background task to the system, assuming the system is in a low-power standby state or intermittent activity state, and that there are practical constraints such as concurrent submission of multiple source tasks, potential dependencies between tasks, and the timeliness of credentials. The reason for completing rich metadata encapsulation and real-time energy consumption and reputation assessment at task submission is that subsequent dynamic priority calculation, dependency verification, wake-up merging decisions, and execution budget allocation all strictly rely on traceable and quantifiable task semantics and environmental semantics. If this information is supplemented separately after the task arrives in the queue, the scheduler may lack necessary energy consumption prediction and reputation basis at critical decision points, resulting in unnecessary wake-ups or execution failures, thereby reducing the overall system energy efficiency and increasing retry costs. Therefore, step S1 not only undertakes the responsibility of recording, but also forms a "feedforward protection" for the subsequent scheduling chain by embedding energy consumption prediction and real-time reputation verification at the source. This not only maximizes the success rate of tasks, but also avoids frequent wake-ups triggered by misjudgments, significantly improving the stability and auditability of standby energy consumption management.

[0073] In one possible embodiment, step S1 outputs... Static priority It includes the following:

[0074] Sub-step 101: Receive task requests and generate task metadata records, including task identifier, dependencies, declared resource requirements and estimated execution time, and write them into the task registration table to form the initial task entry;

[0075] Sub-step 102: Calculate the wake-up energy consumption estimate and the real-time reputation score based on the task metadata record. The energy consumption estimate reflects the power consumption requirement of the task during the wake-up cycle, and the reputation score is calculated based on the task's historical completion rate and resource usage accuracy.

[0076] Sub-step 103: Based on the estimated wake-up energy consumption and real-time reputation score, generate a static priority and write the dynamic priority field into the task registration table as the basis data for subsequent scheduling admission;

[0077] Sub-step 104: When a task dependency is not met or the number of historical failures exceeds the threshold, mark the task as a delayed verification state and attach a waiting condition flag so that admission can be re-determined in subsequent verification cycles.

[0078] In a further technical solution, task dependency verification can be performed synchronously after generating task metadata records, and pre-screening can be performed on tasks with unregistered dependencies to reduce invalid access requests; an expiration timestamp can be set after the dynamic priority field is written, and priority decay can be automatically triggered when a task is not scheduled for execution within the set period to maintain the fairness and real-time nature of resource allocation.

[0079] Furthermore, the wake-up energy consumption estimate is obtained by calculating the resource requirements declared in the task (including CPU time, storage access, I / O call count, etc.) and the unit power consumption model of the device; for example: wake-up energy consumption estimate = Σ (resource requirements × corresponding resource power consumption coefficient); where the resource power consumption coefficient is obtained by monitoring or pre-calibrating during device operation, and the unit is energy / operations; the instant reputation score is obtained by calculating based on the task's historical execution records, combining the resource accuracy index and the latency reliability index; where, resource accuracy index = 1 - |declared resources - actual resources| ÷ declared resources; latency reliability index = 1 - actual latency ÷ declared latency; the instant reputation score is the weighted average of the above two indices: reputation score = α × resource accuracy index + β × latency reliability index; the weights α and β are preset in the scheduling strategy, reflecting the relative importance of resource accuracy and timeliness reliability;

[0080] The static priority calculation process is as follows: the estimated wake-up energy consumption and the real-time reputation score are input into the priority generation function to reflect the balance between energy consumption sensitivity and task reliability: Static priority = γ × (1 - normalized energy consumption estimate) + δ × real-time reputation score; the normalized energy consumption estimate refers to the ratio of the current task's energy consumption to the maximum energy consumption of the same batch of tasks; the weight parameters γ and δ are used to control the proportion of the influence of energy consumption and reputation on priority.

[0081] In one possible embodiment, the weight parameters α and β in the instant reputation score are determined as follows: During the initialization phase, the system collects sample data of recently completed tasks, including the resource accuracy deviation rate and latency reliability deviation rate for each sample. Subsequently, a multiple linear regression model is used, with the resource accuracy deviation rate and latency reliability deviation rate as independent variables and the indicator of whether the task was successfully completed as the dependent variable. The standardized coefficients of the two independent variables obtained from the regression analysis are normalized and used as the initial values ​​of weights α and β, respectively. During operation, the system calculates the overall failure rate of tasks within a predetermined number of scheduling cycles. If the failure rate is higher than a preset threshold, the weight α corresponding to the resource accuracy deviation rate is increased by a fixed step size; if the failure rate is lower than the preset threshold, the weight β corresponding to the latency reliability deviation rate is increased by a fixed step size, thereby achieving dynamic calibration of the weights.

[0082] The explanation explains that the weighting parameters α, β, γ, and δ mentioned above are all quantifiable empirical parameters used to balance energy consumption constraints and task reputation impact under different task scenarios. In the initial deployment phase, a certain number of historical task samples are collected, and the resource deviation rate and latency deviation rate of each sample are calculated. Regression analysis is used to obtain the sensitivity coefficients of resource deviation and latency deviation to task failure rate. The relative weights of α and β are determined according to their ratio, with values ​​ranging from 0.3 to 0.7 and a sum of 1. The energy consumption sensitivity weight γ is set based on the device type and power consumption limit, while the reputation sensitivity weight δ is dynamically adjusted based on the number of task retries and failure rate, with values ​​ranging from 0.4 to 0.6, and a sum of 1 to maintain the stability of the calculation results. During operation, after a certain number of scheduling events, the energy consumption error and task failure rate are automatically evaluated. If the energy consumption error exceeds a preset threshold, γ is adjusted; if the failure rate increases, δ is increased. The adjustment results and timestamps are written to the parameter configuration table to achieve dynamic calibration and traceable management of the weighting parameters.

[0083] The purpose of static priority is to serve as a baseline reference for task scheduling and resource allocation, determining the initial ranking position of a task in the execution queue before dynamic calculation or adjustment. This initial value reflects the estimated importance and time sensitivity of the task during the design or submission phase, and is the starting point for subsequent dynamic priority adjustments (such as adjustments based on time sensitivity integrity index or credential availability index). Its main uses include:

[0084] First, during the task submission phase, an initial scheduling sequence can be quickly generated based on static priorities, enabling the system to make basic sorting and admission decisions before calculating dynamic indicators, thus avoiding scheduling gaps.

[0085] Secondly, during the execution phase, when dynamic priority calculation cannot be completed due to missing or delayed data, static priority serves as a fallback reference to ensure that the task can still be reasonably scheduled.

[0086] Third, during the credit update and quota adjustment process, static priority and the revised dynamic priority are both used in historical comparison to evaluate the effect of strategy adjustment and the stability of task execution.

[0087] Therefore, static priority is not only the initial basis for task scheduling, but also a reference for subsequent dynamic priority correction and reputation assessment, playing a fundamental role in maintaining the continuity of scheduling logic and the stability of energy consumption control.

[0088] The process of generating task metadata records in step S1 further includes:

[0089] The estimated wake-up power consumption of a task is dynamically coupled with the power state and memory frequency of the underlying hardware chip, with the expected wake-up power state as the core variable. Based on the accuracy of resource claims and the history of execution reliability in the task metadata record, visualized task reputation data is generated. A mapping relationship is established between static priority and the safety level or real-time level defined in the functional safety standard. For tasks involving critical safety or hard real-time functions, their static priority surpasses the conventional calculation rules based on power consumption estimation and reputation score through a preset strategy.

[0090] S2 Dynamic Priority Calculation Steps: At each scheduling decision point, the scheduler calculates a dynamic priority score for each task in the queue based on the task metadata and the current time. The dynamic priority score is obtained by weighting the static priority with a preset weight, and the dynamic priority score is written back to the task metadata for sorting purposes.

[0091] In one implementation, the generation of the time-sensitive integrity index includes the following process:

[0092] Extract the historical failure rate time series related to the task from the task execution state memory, and perform trend extraction and smoothing operations on the series within a sliding window to obtain the latency sensitivity component that characterizes the execution stability; the smoothing operation can adopt a recursive exponential weighting method, and its smoothing coefficient can be adaptively adjusted according to the degree of historical fluctuation.

[0093] The remaining delay time is calculated based on the task plan deadline and the current execution time. Combined with the real-time collected delay samples, the variance of the delay samples is estimated within a local time window to obtain the time vulnerability component that characterizes short-term volatility risk.

[0094] The latency-sensitive component and the time vulnerability component are input into a nonlinear fusion function (which can be a sigmoid type or other continuously differentiable function to balance the impact of long-term stability and short-term risk) for mapping operation, and the time-sensitive integrity index is output. This index can adaptively adjust under different task execution fluctuation conditions, effectively reflecting the time sensitivity of the task under standby power consumption control.

[0095] In one implementation, the calculation of the credential availability index includes the following steps:

[0096] The voucher update success rate component is calculated by statistically analyzing the number of successful and failed voucher updates within the most recent task cycles from the voucher update records.

[0097] Then, the delay time distribution features are extracted from the recorded update delay samples, and the update delay trend in the near future is estimated by moving average or time series autoregressive prediction methods.

[0098] A risk-weighted value is calculated based on the predicted delay and the remaining validity time of the current credential to reflect the availability of the credential under the current power consumption state; the success rate component and the risk-weighted value are then combined according to a preset ratio to obtain the credential availability index.

[0099] The above calculation method can be used to quantitatively describe the stability of the credential status and the risk of short-term failure, thereby effectively avoiding the increase in power consumption caused by security verification failure or repeated handshakes when making scheduling priority decisions.

[0100] The explanation explains that the "trend extraction and smoothing calculation" employs an exponentially weighted moving average algorithm with a fixed smoothing coefficient λ of 0.2 and a fixed sliding window size of the most recent 10 historical execution cycles. The "nonlinear fusion function" specifically uses the Sigmoid function, expressed as f(x) = 1 / (1 + e^(-k*(x-x0))), where parameter k is 2, x0 is 0.5, and the input x is the weighted sum of the delay sensitivity component and the time vulnerability component. The "autoregressive prediction method" uses a first-order autoregressive model, with model coefficients obtained by fitting the most recent 20 voucher update delay time series using the least squares method. These specific parameter settings ensure that the calculation process can be stably reproduced.

[0101] In a further embodiment, the process of generating the dynamic priority score includes:

[0102] The aforementioned time sensitivity integrity index and document availability index are input as two input variables into a predefined mapping model. This mapping model can adopt linear interpolation, piecewise function or logical mapping based on empirical threshold to determine the degree of coordination between the two. The alignment coordination index output by the mapping is used to indicate the matching level between time sensitivity and security availability. When the alignment coordination index is lower than the preset threshold, a priority correction operation is performed.

[0103] Priority adjustment refers to the weighted adjustment of static priorities. The weighting direction is automatically determined based on the trend of the alignment and coordination index to ensure that tasks are scheduled and executed first in high-risk or high-time-sensitivity scenarios, while tasks can be delayed in low-risk and low-sensitivity scenarios.

[0104] The weighting direction in the priority correction operation is determined based on the relationship between the alignment coordination index and a preset threshold: when the alignment coordination index is lower than the first threshold, the static priority is weighted upward; when the alignment coordination index is higher than the second threshold, the static priority is weighted downward; wherein, the first threshold is less than or equal to the second threshold.

[0105] The corrected dynamic priority score is directly used as the basis for subsequent task scheduling and power consumption control, thereby achieving adaptive matching between task execution order and energy consumption status.

[0106] The explanation is as follows: The process of calculating the dynamic priority score in step S2 further includes:

[0107] Based on the remaining delay time and historical execution stability of a task, an event-triggered incremental update method is used to calculate the dynamic urgency of the task, wherein the dynamic urgency increases stepwise as the remaining delay time decreases. The credential availability state is modeled as a state machine including valid, near-expiration, and invalid states. State transitions are driven by responding to credential update events, and the credential availability index is obtained by looking up a table based on the current state and the remaining validity time. According to the dynamic urgency and credential availability index, combined with the current system load, a final dynamic priority score is generated through a predefined power consumption-performance trade-off strategy, and the initial power state used when waking up the hardware is determined based on this score.

[0108] S3 Dependency Verification and Scheduling Steps: Candidate tasks are filtered according to dynamic priority scores, and dependency verification is performed to determine whether a task should be allowed, suspended, or an error callback should be triggered.

[0109] The explanation is as follows: During the task dependency verification process, the execution status record of the dependent tasks is automatically written into the execution status storage table by the task execution thread when the task starts, completes, or terminates abnormally. The storage table includes the task identifier, current execution flag, completion flag, failure flag, and status update time. The verification process is triggered once in each alignment scheduling cycle. Based on the current cycle time, the dependency status of each candidate task in the task queue is traversed and checked.

[0110] The explanation is as follows: when the completion flag of a dependent task is detected to be true, and its status update time is later than the last verification time of the current task, the verification process determines that the dependency condition is met, marks the task as a release state, and generates a release flag which is written to the task queue. When the scheduling cycle arrives, the execution thread reads the flag and starts the corresponding task execution, thereby avoiding the waste caused by repeated wake-ups when the dependency is not met.

[0111] The explanation explains that if the detection result indicates that the dependent task is still executing or has not yet started, the current task is marked as suspended during the verification process, and a delay monitoring field is written to the task record. This field records the identifier and delay conditions of the dependent task. When the status of the dependent task is updated to complete in a subsequent cycle, the suspended mark is automatically cleared, and the task enters the released state. In this way, delay coordination of task execution can be achieved under energy-constrained conditions, avoiding peak power consumption caused by the simultaneous activation of multiple tasks.

[0112] The explanation is as follows: if the detection result shows that the failure flag of the dependent task is true, or if no status update is detected within the preset time window, an error callback event is generated during the verification process. The error event contains the task identifier, failure reason and dependent path information, and is recorded in the error log. After the error callback is triggered, the task scheduling logic can perform rescheduling or select an alternative task path, thereby restoring the system execution flow without reactivating all dependent tasks and reducing power consumption loss caused by retries.

[0113] In summary, the above dependency verification process introduces real-time status judgment and delayed wake-up control at critical moments of task execution, enabling the dependencies between tasks to dynamically adapt to the system's energy consumption status, ensuring that task execution is only initiated when necessary, thereby reducing the overall energy consumption during standby.

[0114] The dependency verification process in step S3 further includes:

[0115] A completion time prediction model is established based on historical execution data of dependent tasks, and verification preparation is pre-triggered before the estimated completion time; a task dependency graph is constructed to identify key execution paths, and batch verification is implemented for task groups with common dependencies; a verification strategy is dynamically selected according to the current power state of the system, and a simplified verification mode is adopted in low power state; a degraded execution scheme is preset for key dependencies, and a backup path is activated based on task reputation score when verification fails; the prediction of the completion time of dependent tasks in step S3 is achieved through a time prediction model, which is obtained by collecting target data and collecting historical operation data generated by the target device during the execution of dependent tasks. The historical operation data includes at least the planned execution time of the task, the actual execution time, system load records, hardware resource utilization, and success / failure status. The system employs a multi-stage approach: Preprocessing the collected data, including data cleaning to remove obviously abnormal records and data normalization to eliminate the influence of different units of measurement; using a Long Short-Term Memory (LSTM) network as the basic model structure; introducing a frequency domain supervision mechanism during training, specifically: converting the predicted time-series data output by the completed time prediction model into first reference predicted frequency domain data, and simultaneously converting the actual training label time-series data into reference frequency domain data; constructing a frequency domain loss function by calculating the difference between the two, and using it in conjunction with the conventional time-domain prediction loss function to guide model training; encapsulating the trained model parameters into a prediction function library and integrating it into the device's task scheduling service; during deployment, the prediction function library receives metadata of the dependent tasks and the current system state as input, and outputs the predicted time point of task completion and a confidence interval. The time prediction model in the dependency verification process is implemented as follows: Historical planned duration, actual duration, system load, and hardware utilization data of tasks are collected from kernel scheduler logs and power management records. Data preprocessing is performed using outlier filtering and maximum / minimum normalization based on the three-sigma principle. A Long Short-Term Memory (LSTM) network is used as the model foundation. During training, a Fast Fourier Transform (FFT) is introduced to convert the predicted and actual sequences into frequency domain data. A frequency domain loss function is constructed by calculating the mean square error of the spectral amplitude, and this function is weighted with the time domain mean square error loss according to preset weights to guide model optimization. The trained model is encapsulated as a prediction interface, receiving the task feature vector and outputting the prediction timestamp and confidence interval. During dependency verification, a directed acyclic graph is constructed by parsing the dependency list in the task metadata. The critical path method is used to identify critical tasks, and batch status queries are performed on task groups with common dependencies. Based on the device power state switching verification strategy, only the task completion flag is queried in low-power mode. When verification fails, a preset degraded execution function is invoked based on the task reputation score threshold. To clarify, during the task execution phase, verified tasks are input into the execution control process.The execution control process is constrained by the execution budget allocated in the current wake-up cycle, and quota-based scheduling is performed using a controlled context manager. The execution budget is measured in units of available processor time slices or energy consumption limits, and the execution quota Q = E × p / Σp is calculated based on the current remaining energy E and the task priority p. The execution quota is determined as follows: based on the current system's available energy budget and the task's dynamic priority score, energy is allocated proportionally according to priority weights, and the allocated energy value is converted into corresponding processor execution time as the task's execution quota.

[0116] The explanation is as follows: Before each segment execution, the execution control process records the current task's progress pointer, local variable status, and list of incomplete operations. When the remaining budget is detected to be lower than a preset threshold ε (ε is 1.2 times the task switch save time), an interrupt operation is triggered. The interrupt operation writes the progress pointer and local state to non-volatile storage medium, forming a suspended execution context, and attaches a timestamp and progress tag to it to identify the specific location of the task interruption and the remaining workload. This progress tag is parsed as a recovery entry point during the next wake-up, thereby ensuring that the task can continue to advance during different wake-up cycles. If a task is completed normally within the execution cycle, the execution control process updates its status field to "complete" and generates a task completion flag. If a task needs to be resumed first after an interruption, a priority resumption tag is written into the suspension context. The weight P of the priority resumption tag is calculated by multiplying and adding the dependency urgency u and the incomplete proportion r with predefined weights. When the scheduler scans the task queue, it will prioritize waking up tasks with high weight P, thereby reducing the time loss caused by repeated context switching. In this way, controllable interruption and rapid resumption of task execution can be achieved in scenarios with limited power consumption or high real-time requirements, ensuring execution continuity and improving overall operating efficiency.

[0117] S4 Controlled Execution Steps: During the wake-up window, a controlled execution context is created for the verified task, and the task is suspended with a recovery tag when the run quota is reached or the interruption condition is triggered.

[0118] Furthermore, the execution control process performs quota-based scheduling based on the currently awakened execution budget within each execution cycle. When budget exhaustion is detected, an interrupt operation is automatically triggered, and the task's progress pointer, local variable stack, and list of incomplete operations are written to non-volatile storage to form a suspended execution context. A timestamp and progress tag are appended to this context to identify the interruption location, and a priority recovery tag is calculated based on the task's dependency urgency and incomplete proportion, so that tasks with priority recovery tags are awakened first in the next scheduling cycle to reduce context switching latency and maintain task execution continuity.

[0119] S5 reputation feedback steps: Record task execution results and resource consumption, generate reputation records, and adjust task resource allocation based on these records during subsequent policy refreshes.

[0120] Furthermore, based on the actual resource consumption recorded during task execution and the resource consumption declared at the time of task submission, a comparison is performed item by item to generate a multi-dimensional resource consumption deviation vector, where each component of the vector corresponds to the relative deviation rate between the declared and actual values ​​of a resource type. A task resource accuracy index is calculated based on the deviation vector, obtained by calculating the Euclidean norm of the deviation vector and linearly mapping it. Simultaneously, a latency reliability index is calculated, based on the deviation between the actual and declared latency of the task, using a preset formula and constrained to be non-negative. The task resource accuracy index and latency reliability index are combined using a weighted arithmetic mean to form a unified task reputation profile, where the weighting weights are configurable parameters predefined in the strategy engine. In subsequent strategy refresh cycles, the strategy engine quantitatively corrects the task priority based on the value of the task reputation profile. This correction is achieved by multiplying the original dynamic priority by a linear function of the reputation profile, while simultaneously scaling the task's execution time slice quota proportionally based on the value of the task reputation profile.

[0121] Example 2 Scenario Summary: In the network standby scenario of mobile terminals (such as smartphones and IoT devices), the system needs to continuously respond to wake-up requests from multiple sources such as the network, sensors, and applications. If each request wakes up and executes independently, it will cause hardware such as the communication module, positioning module, and processor to be frequently activated, generating a large amount of redundant power consumption and severely shortening the device's battery life. To solve the problem of how to reduce unnecessary wake-up and power consumption in the standby scenario of mobile terminals by intelligently merging wake-up source events, dynamically adjusting window mapping and positioning strategies, while ensuring the positioning requirements of high-time-efficiency tasks, the alignment window mechanism of Example 2 is set up.

[0122] The core significance of the alignment window mechanism lies in its ability to intelligently merge multiple discrete wake-up events within a short period into a pre-defined time window for batch processing. This compresses multiple fragmented "power-on-execute-sleep" cycles into a single centralized process, significantly reducing the overall number of system wake-ups and the activation duration of hardware modules (especially high-power communication and positioning modules). This mechanism dynamically balances merging efficiency with task timeliness: maximizing power saving through merging while ensuring that high-timeliness and high-precision task requirements (such as emergency messages and real-time navigation) are not delayed or degraded. Its ultimate goal is to achieve a balance between minimizing standby power consumption and ensuring controllable service quality.

[0123] The explanation explains that while the priority mechanisms in Embodiment 1 and Embodiment 2 differ fundamentally in function and hierarchy, they are closely collaborative. Embodiment 1's task-level priority focuses on micro-scheduling, its core being determining the execution order of individual tasks in the queue. It dynamically calculates based on attributes such as task timeliness, security credentials, and historical reputation, aiming to answer the question, "Which task should be executed next?" Embodiment 2's window-level priority, on the other hand, operates on macro-level power management, its core being evaluating the merging value and timing of a group of wake-up source events. It generates window parameters by analyzing the statistical characteristics of event clusters (such as cluster coupling) and system environment states (such as location reliability), aiming to answer the question, "Whether and how should multiple execution requests be merged into the same wake-up window?" The connection between the two lies in their strict process integration and data dependency: tasks scheduled by Embodiment 1 are transformed into wake-up source events, becoming the processing objects of Embodiment 2; the former ensures the responsiveness of critical tasks, while the latter, based on this, maximizes the merging of wake-up counts, together forming a complete low-power control chain from "precise scheduling" to "batch execution."

[0124] See Figure 2 The flowchart of the wake-up source event alignment window is shown in this embodiment of the invention. After step S3, an alignment window mechanism is further included, which calls the phase and positioning determination sub-step, including:

[0125] Establish a wake-up source event queue through the communication and system layers, and write the source type, timeliness level, location requirement identifier and dependency relationship for each event. Initialize the alignment window schedule and set the initial window step size and offset with the strategy adjustment factor.

[0126] The perception layer generates motion state tags, and reads the location result cache and location strategy status from the data and configuration layer. The wake-up source event queue is merged and deduplicated according to source type and dependency relationship to form a merged batch list.

[0127] The alignment window executor is initiated to map the merged batch list into the alignment window schedule and generate a communication session profile and system resource mapping for each window; during this process, dynamic decisions are made by calculating the cluster wake-up coupling index and the location availability uncertainty index.

[0128] The calculation method for the cluster wake-up coupling index is as follows: First, the timestamp sequence of the wake-up source event queue is burst-segmented, and the mutual information increment between different source types is obtained. Then, a randomized control sequence that keeps the marginal rate of each source type constant is used as a benchmark to calculate the mutual information ratio between the actual sequence and the random sequence. Finally, the ratio is logarithmically compressed to obtain a dimensionless index. The calculation method for the positioning availability uncertainty index is as follows: First, based on the motion state label, the time staleness of the positioning result cache and the source type are combined, and the cache location confidence decay term is calculated through a preset decay formula. Then, the confidence decay term is updated in Bayesian form using signs of changes in the surrounding wireless environment as external observation evidence to obtain a normalized dimensionless uncertainty.

[0129] The calculated cluster wake-up coupling index and the location availability uncertainty index are input together into the predefined window priority coefficient model, and a comprehensive dimensionless window priority coefficient is output by linear weighted summation.

[0130] The window priority coefficient is a dimensionless value between [0, 1]. A higher window priority coefficient indicates a greater tendency to open the window and perform deep merging as early as possible; a lower window priority coefficient indicates a more cautious approach to opening the window and prioritizing low latency and positioning accuracy. The system determines the specific window mapping offset and task merging depth within the current window based on the window priority coefficient. Simultaneously, a positioning strategy decision is made: the system will switch to real-time positioning within the current window only if the candidate task in the merging batch list identifies a high-timeliness positioning requirement, and the window priority coefficient model output indicates that the current positioning availability uncertainty has exceeded the threshold (i.e., cached positioning cannot meet accuracy requirements). Otherwise, the system will directly send the location information from the cached positioning results.

[0131] Within the opened alignment window, batch processing is performed based on the system resource mapping, merging the operations of multiple tasks into a single power-on transaction; when the window closes, an execution summary is generated and the next cycle window parameters are updated based on the policy adjustment factor, subsequently triggering the system to enter a hibernation state.

[0132] Specifically, during the alignment window's open period, batch processing tasks are executed according to the generated system resource mapping. The originally independent same-source communication handshake, data transmission and reception, and application callback operations are merged into a single power-on transaction for continuous execution. The release timing of wake-up records related to this batch processing is strictly limited by the batch tail trimmer module to prevent resource occupation from preventing the device from sleeping. When the window closes, an execution summary is generated and written to the data and configuration layer. Subsequently, based on the strategy adjustment factor and the execution status, the step size and offset of the next round of alignment window plan table are fine-tuned. Finally, the communication and system layer issues a system sleep command to put the device into a low-power state.

[0133] In a possible embodiment, the specific process for calculating the cluster wake-up coupling index is as follows: First, the event source types occurring within the burst cluster are classified into a random variable X, and the order number obtained by sorting each event within the cluster according to its occurrence time is classified into another random variable Y. Next, by counting the number of times each specific source type and each specific order position combination occurs within the burst cluster, the joint probability distribution P(X, Y) of these two random variables, as well as their respective independent marginal probability distributions P(X) and P(Y), are estimated. Then, according to the standard formula for calculating mutual information, i.e., summing over all x and y, P(x, y) is multiplied by log P(x, y) divided by the logarithm of the product of P(x) and P(y), thereby obtaining the mutual information of the actual event sequence. For the randomized control sequence, the calculation of its mutual information uses the exact same formula and method, but the sequence on which the calculation is based is a new sequence generated by randomly shuffling the original time order while keeping the frequency of occurrence of each source type unchanged. Finally, the cluster wake-up coupling index is obtained by calculating the ratio of the actual mutual information to the randomized sequence mutual information and taking the natural logarithm of that ratio.

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

Claims

1. A method for controlling the standby power consumption of an intelligent control system, characterized in that, include: S1 Task Submission Steps: When submitting a task, generate a task metadata record for each task, which includes static priority, maximum allowed delay, and a list of dependent tasks, and store it in the task queue. S2 Dynamic Priority Calculation Steps: At the scheduling decision point, a dynamic priority score is calculated for the tasks in the queue based on the task metadata and the current time. The dynamic priority score is achieved by weighting the static priority. The weighting direction is automatically determined based on the trend of the alignment coordination index. The alignment coordination index is a dimensionless score obtained by inputting the task's time limit pressure, authentication validity status, historical completion stability, and current remaining delay time into a predefined mapping model and normalizing it. It is used to measure the degree of matching between the task and the alignment window and dynamically correct the priority and guarantee / delay flag accordingly. S3 Dependency Verification and Scheduling Steps: Candidate tasks are filtered according to dynamic priority scores, and dependency verification is performed to determine whether a task should be allowed, suspended, or an error callback should be triggered. S4 Controlled Execution Steps: During the wake-up window, a controlled execution context is created for the verified task, and the task is suspended with a recovery tag when the run quota is reached or the interruption condition is triggered. S5 reputation feedback steps: Record task execution results and resource consumption, generate reputation records, and adjust task resource allocation based on these records during subsequent policy refreshes.

2. The method for standby power consumption of an intelligent control system according to claim 1, characterized in that, The static priority acquisition method includes: Receive a task request and generate a task metadata record; calculate the estimated wake-up energy consumption and real-time reputation score based on the task metadata record; generate a static priority based on the estimated wake-up energy consumption and the real-time reputation score. The wake-up energy consumption estimate is obtained by calculating the resource requirements declared in the task and the unit power consumption model of the device. The instant reputation score is obtained by calculating the resource accuracy index and latency reliability index based on the task's historical execution records. The instant reputation score is the weighted average of the resource accuracy index and latency reliability index. The static priority is calculated by the following formula: Static priority = γ × (1 - normalized energy consumption estimate) + δ × instant reputation score, where γ and δ are the weight parameters of each item.

3. The method for standby power consumption of an intelligent control system according to claim 2, characterized in that, The dynamic priority score is obtained as follows: The time sensitivity integrity index and the credential availability index are input as two input variables into the predefined mapping model. The alignment coordination index output by the mapping is used to indicate the matching level between time sensitivity and security availability. When the alignment coordination index is lower than the preset threshold, a priority correction operation is performed. Priority adjustment refers to the weighted adjustment of static priorities. The weighting direction is automatically determined based on the trend of the alignment and coordination index to ensure that tasks are scheduled and executed first in high-risk or high-time-sensitivity scenarios, while tasks can be delayed in low-risk and low-sensitivity scenarios. The corrected dynamic priority score is directly used as the basis for subsequent task scheduling and power consumption control, thereby achieving adaptive matching between task execution order and energy consumption status. The generation process of the time-sensitive integrity index includes: extracting the historical failure rate time series from the task execution state memory, performing trend extraction and smoothing operations within a sliding window to obtain the delay sensitivity component; calculating the remaining delayable time based on the task schedule deadline and the current execution time, and estimating the delay sample variance by combining real-time collected delay samples to obtain the time vulnerability component; inputting the delay sensitivity component and the time vulnerability component into a nonlinear fusion function for mapping operations, and outputting the time-sensitive integrity index. The calculation process of the voucher availability index includes: counting the number of successful and failed voucher updates in the recent task cycles from the voucher update records, and calculating the voucher update success rate component; extracting the delay time distribution characteristics from the recorded update delay samples, and estimating the update delay trend in the near future through a prediction method; calculating the risk weighting value based on the predicted delay and the remaining valid time of the current voucher, and merging the success rate component and the risk weighting value according to a preset ratio to obtain the voucher availability index.

4. The method for standby power consumption of an intelligent control system according to claim 3, characterized in that, The availability status of credentials is modeled as a state machine that includes valid, near-expiration, and invalid states. State transitions are driven by responding to credential update events, and the credential availability index is obtained by looking up a table based on the current state and the remaining validity time.

5. The method for standby power consumption of an intelligent control system according to claim 3, characterized in that, The execution control process for the verified task in step S3 includes: The execution budget allocated in the current wake-up cycle is used as a constraint, and a controlled context manager is used for quota scheduling. The execution budget is measured in units of processor available time slices or energy consumption limits, and the execution quota is calculated based on the current remaining energy E and task priority p. The execution quota is determined in the following way: based on the current system's available energy budget and the task's dynamic priority score, it is allocated proportionally according to the priority weight, and the allocated energy value is converted into the corresponding processor execution time as the execution quota for the task. Before each segment is executed, record the progress pointer, local variable status, and list of incomplete operations for the current task; When the remaining budget quota is detected to be lower than the preset threshold ε, an interrupt operation is triggered, the progress pointer and local state are written to non-volatile storage medium to form a suspended execution context, and a timestamp and progress tag are attached. Write a priority recovery label in the suspended context. The weight P of the priority recovery label is calculated by multiplying and adding the dependency urgency level u and the incomplete proportion r with predefined weights. When the scheduler scans the task queue, it prioritizes waking up tasks with high weight P.

6. The method for standby power consumption of an intelligent control system according to claim 5, characterized in that, The dependency verification process in step S3 includes dependency task completion time prediction based on a prediction model. The prediction model can be obtained in the following ways: Historical execution data of dependent tasks are collected, including planned execution time, actual execution time, system load, and hardware resource utilization. Data preprocessing is performed, including outlier filtering and data normalization. A Long Short-Term Memory (LSTM) network is used as the basic model structure. A frequency domain supervision mechanism is introduced during training: the predicted time-series data output by the model and the actual training label time-series data are converted to frequency domain data respectively. A frequency domain loss function is constructed by calculating the difference between the two, and it is used in conjunction with the time-domain prediction loss function to guide model training. The trained model is encapsulated as a prediction function library, which receives metadata of the dependent tasks and the current system state as input, and outputs the predicted time point and confidence interval for the task completion.

7. The method for standby power consumption of an intelligent control system according to claim 6, characterized in that, The controlled execution step S4 specifically includes: When the window is opened, a wake-up token is generated by the communication and system layer and managed by the kernel-mode token custodian. The token is forcibly reclaimed at the window boundary, and any hold-on wake-up not released before the boundary is released when the token expires; Requests added during the window period that do not meet the timeliness level are written to the subsequent queue.

8. The method for standby power consumption of an intelligent control system according to claim 1, characterized in that, The credit feedback step S5 specifically includes: The actual resource consumption recorded during task execution is compared with the resource consumption declared when the task is submitted to generate a resource consumption deviation vector. Based on the resource consumption deviation vector, calculate the task resource accuracy index and latency reliability index to form a task reputation profile; During the policy refresh cycle, the policy engine generates correction instructions for queue sorting, priority guarantee identifiers, and execution budget allocation weights based on the task reputation profile, available execution budget, and task dynamic priority.

9. The method for standby power consumption of an intelligent control system according to claim 1, characterized in that, The dependency verification and scheduling steps are followed by an alignment window scheduling step, which specifically includes: Establish a wake-up source event queue, and write the source type, timeliness level, and location requirement identifier for each event in the queue; Based on the motion state tags provided by the perception layer and the positioning result cache provided by the data layer, the events in the wake-up source event queue are merged and deduplicated to generate a merged batch list. Calculate the cluster wake-up coupling index and the location availability uncertainty index; input the cluster wake-up coupling index and the location availability uncertainty index into a predefined window priority coefficient model, and obtain the window priority coefficient through linear weighting; the weights are set based on the actual situation. Based on the window priority coefficient, determine the window mapping offset and task merging depth of the current alignment window; Based on the merged batch list and the location availability uncertainty index, a location strategy decision is made: if and only if there are candidate items in the list that indicate high timeliness location needs and the location availability uncertainty index exceeds a preset threshold, real-time location is enabled within the current alignment window; otherwise, cached location results are sent. Within the opened alignment window, batch processing is performed based on the system resource mapping, merging the operations of multiple tasks into a single power-on transaction; when the window closes, an execution summary is generated and the next cycle window parameters are updated based on the policy adjustment factor, subsequently triggering the system to enter a hibernation state.

10. A method for managing standby power consumption in an intelligent control system according to claim 9, characterized in that, The calculation of the cluster wake-up coupling index includes: The timestamp sequence in the wake-up source event queue is burst-segmented to form at least one burst cluster; For each burst cluster, the event source type sequence is considered as the first random variable, and the event's temporal triggering order index within the cluster is considered as the second random variable. The joint probability distribution and individual marginal probability distributions of the first and second random variables are estimated by statistically analyzing their joint occurrence frequency. The actual mutual information value between the first and second random variables is calculated using the mutual information formula. A randomized control sequence is generated that maintains the marginal occurrence rate of each source type, and its control mutual information value is calculated. The ratio of the actual mutual information value to the control mutual information value is calculated, and the natural logarithm of this ratio is taken to output the cluster-on-wake coupling index. The calculation of the location availability uncertainty index includes: calculating the cache location confidence decay term using a confidence decay model based on motion status tags, the time staleness of the location result cache, and the type of location source, as a prior probability; obtaining the number of new nodes in the surrounding wireless network environment per unit time as external observation evidence; using a Bayesian update formula to fuse the prior probability with the external observation evidence to obtain the posterior probability; and outputting the difference between 1 and the posterior probability as the location availability uncertainty index.

Images