An adaptive dynamic power consumption adjustment method and system for internet of things devices

Abstract

The application relates to the technical field of Internet of Things device power consumption management, and discloses a self-adaptive dynamic power consumption adjustment method and system for an Internet of Things device, which comprises the following steps: acquiring real-time environment parameters and operation parameters of the Internet of Things device, and generating a current multi-dimensional state vector through coding; inputting a multi-dimensional state space, matching and determining a current state node, and extracting a set of bound basic hardware control parameters thereof; acquiring adjacent nodes of the current node, extracting a historical state transition path thereof, and calculating a parameter offset trend vector; fusing the set of basic parameters and the trend vector, generating a target instruction set, and issuing an adjustment; collecting actual energy consumption and environment parameters, calculating an execution deviation value, correcting current and adjacent node coordinates according to the deviation value, and updating the set of basic parameters. The application improves the power consumption efficiency, environmental adaptability and long-term operation stability of the Internet of Things device under complex and changeable environments.

Description

Technical Field

[0001] This application relates to the field of power management technology for Internet of Things (IoT) devices, and in particular to an adaptive dynamic power consumption adjustment method and system for IoT devices. Background Technology

[0002] With the widespread deployment of IoT technology in smart homes, industrial monitoring, smart cities, and other fields, massive numbers of edge terminal devices typically rely on limited battery power for long-term unattended operation. This makes power management a core critical factor determining the lifespan and reliability of these devices. When IoT devices operate in real physical environments, their energy consumption levels are not determined by a single variable, but are deeply influenced by the interplay between physical environment parameters and the device's own operating status. To address this complex energy consumption constraint, existing power regulation mechanisms have gradually evolved from simple static threshold shutdowns to dynamic adjustments based on multi-dimensional sensor data, dynamically allocating computing and communication resources by sensing the device's internal and external states in real time.

[0003] However, in practical applications, traditional dynamic power consumption regulation schemes mostly rely on preset static rule bases or parameter mapping lookup tables at a single moment. This makes it difficult to capture the dynamic trends during gradual changes in environment and load. Consequently, when faced with complex conflict scenarios such as high temperature accompanied by high load, or low battery level combined with weak signals, parameter adjustments are prone to drastic jumps or getting trapped in local suboptimal solutions. Furthermore, existing feedback control often only provides linear compensation for errors in a single dimension, failing to transform historical operating experience into long-term adaptive evolution capabilities. This forces the equipment to blindly experiment from scratch when facing unprecedented complex operating conditions during long-term operation, failing to effectively address the technical challenges of low power consumption regulation accuracy, poor system robustness, and lack of continuous self-optimization capabilities in multi-factor dynamically coupled scenarios. Summary of the Invention

[0004] To address the aforementioned technical issues, this application provides an adaptive dynamic power consumption adjustment method and system for Internet of Things (IoT) devices.

[0005] Firstly, this application provides an adaptive dynamic power consumption adjustment method for Internet of Things (IoT) devices, employing the following technical solution:

[0006] Acquire real-time environmental parameters and device operating parameters of IoT devices and encode them to generate the current multi-dimensional state vector;

[0007] The current multidimensional state vector is input into a pre-constructed multidimensional state space for node matching to determine the current state node and extract the set of basic hardware control parameters bound to the current state node; wherein, the multidimensional state space is composed of multiple state nodes formed by clustering historical state vectors, and the spatial location distribution of each state node represents the coupling constraint relationship between power, temperature, network quality and task load.

[0008] Obtain multiple adjacent nodes of the current state node in the multidimensional state space;

[0009] Extract the state transition paths of the multiple neighboring nodes within a historical time period, and calculate the parameter offset trend vector for the current state node based on the state transition paths;

[0010] The basic hardware control parameter set and the parameter offset trend vector are fused together to generate the target hardware control instruction set, which is then sent to the hardware driver layer for adjustment.

[0011] Collect actual energy consumption data and actual state parameters after hardware adjustment, and calculate the execution deviation value for the current state node;

[0012] The spatial position coordinates of the current state node and its adjacent nodes in the multidimensional state space are offset and corrected according to the execution deviation value, and the bound basic hardware control parameter set is updated.

[0013] By adopting the above technical solutions, historical experience is structured using a multi-dimensional state space as a carrier, dynamic changes are captured by adjacent node trend prediction, precise power consumption adjustment is achieved by integrating basic parameters and offset trends, and self-evolution is achieved by reverse correction of the state space through execution deviation. Ultimately, this improves the power efficiency, environmental adaptability, and long-term operational stability of IoT devices in complex and ever-changing environments. It solves the pain point that traditional static strategies or single-parameter feedback control cannot cope with the dynamic changes of multiple coupled factors, and provides core technical support for energy saving and reliable operation of IoT devices.

[0014] Secondly, this application provides an adaptive dynamic power consumption adjustment system for Internet of Things (IoT) devices, employing the following technical solution:

[0015] The state perception and encoding module is used to acquire real-time environmental parameters and device operating parameters of IoT devices and encode them to generate the current multi-dimensional state vector.

[0016] The node matching and parameter extraction module is used to input the current multidimensional state vector into a pre-constructed multidimensional state space for node matching, determine the current state node, and extract the set of basic hardware control parameters bound to the current state node; wherein, the multidimensional state space is composed of multiple state nodes formed by clustering historical state vectors, and the spatial location distribution of each state node represents the coupling constraint relationship between power, temperature, network quality and task load.

[0017] The adjacency node acquisition module is used to acquire multiple adjacency nodes of the current state node in the multidimensional state space;

[0018] The trend prediction calculation module is used to extract the state transition paths of the multiple neighboring nodes within a historical time period, and calculate the parameter offset trend vector for the current state node based on the state transition paths.

[0019] The instruction fusion generation module is used to fuse the basic hardware control parameter set with the parameter offset trend vector to generate a target hardware control instruction set, and send it to the hardware driver layer for adjustment.

[0020] The execution deviation calculation module is used to collect the actual energy consumption data and actual state parameters after hardware adjustment, and calculate the execution deviation value for the current state node.

[0021] The parameter self-evolution module is used to offset and correct the spatial position coordinates of the current state node and adjacent nodes in the multi-dimensional state space according to the execution deviation value, and update the bound basic hardware control parameter set.

[0022] In summary, this application includes at least one of the following beneficial technical effects: This application uses multi-dimensional state space to structure historical experience, uses adjacency trend prediction to capture dynamic changes, integrates benchmarks and trends to achieve precise power consumption adjustment, and reverse correction to promote the self-evolution of the state space, thereby improving the power efficiency, environmental adaptability and long-term operational stability of IoT devices in complex and ever-changing environments. It solves the pain point that traditional static strategies are difficult to cope with the dynamic changes of multiple coupled factors, and provides core technical support for the energy saving and reliable operation of IoT devices. Attached Figure Description

[0023] Figure 1 This is a first flowchart illustrating an adaptive dynamic power consumption adjustment method for IoT devices according to one embodiment of this application.

[0024] Figure 2 This is a second flowchart illustrating an adaptive dynamic power consumption adjustment method for IoT devices according to one embodiment of this application.

[0025] Figure 3This is a third flowchart illustrating an adaptive dynamic power consumption adjustment method for IoT devices according to one embodiment of this application.

[0026] Figure 4 This is a fourth flowchart of an adaptive dynamic power consumption adjustment method for IoT devices according to one embodiment of this application.

[0027] Figure 5 This is a fifth flowchart of an adaptive dynamic power consumption adjustment method for IoT devices according to one embodiment of this application.

[0028] Figure 6 This is a sixth flowchart of an adaptive dynamic power consumption adjustment method for IoT devices according to one embodiment of this application.

[0029] Figure 7 This is a schematic diagram of the seventh process of an adaptive dynamic power consumption adjustment method for IoT devices according to one embodiment of this application.

[0030] Figure 8 This is the eighth flowchart of an adaptive dynamic power consumption adjustment method for IoT devices according to one embodiment of this application.

[0031] Figure 9 This is a ninth flowchart illustrating an adaptive dynamic power consumption adjustment method for IoT devices according to one embodiment of this application. Detailed Implementation

[0032] To make the purpose, technical solution, and advantages of this application clearer, the following description is provided in conjunction with the appendix. Figures 1-9 The present application will be further described in detail below with reference to embodiments. It should be understood that the specific embodiments described herein are for illustrative purposes only and are not intended to limit the scope of the application.

[0033] This application discloses an adaptive dynamic power consumption adjustment method for Internet of Things (IoT) devices.

[0034] Reference Figure 1 An adaptive dynamic power consumption adjustment method for Internet of Things (IoT) devices, specifically including:

[0035] Step S101: Obtain the real-time environmental parameters and device operating parameters of the IoT device and encode them to generate the current multi-dimensional state vector;

[0036] Among them, the power consumption of IoT devices is affected by multiple coupled factors: environmental parameters (such as temperature changes affecting heat dissipation efficiency and chip power consumption, sudden acceleration changes indicating changes in task urgency, and signal strength related to communication module power) and operating parameters (remaining battery power determines the upper limit of available energy, processor load rate reflects computational density, and packet loss rate reflects the impact of network quality on retransmission power consumption) together constitute the overall state.

[0037] In this embodiment, the essence of the encoding process is to solve the problem of unifying heterogeneous parameters. For example, continuous quantities such as temperature, power, and signal strength are compressed to a uniform dimension (such as the [0,1] interval) through linear normalization to eliminate unit differences; acceleration data is generated by mutation detection (such as setting a threshold to identify drastic changes in a short period of time) to generate task urgency indicators (such as 0 representing stability and 1 representing urgency) to capture discontinuous events; and interval parameters such as processor load rate and packet loss rate are normalized by interval mapping (such as mapping the load rate 0%-100% to an integer level of 0-10) to standardize the degree of dispersion.

[0038] Finally, the data, after being spliced ​​and processed according to the preset dimensional order (such as "temperature-acceleration indicator-battery level-load rate-signal strength-packet loss rate"), forms the current multidimensional state vector. Each dimension corresponds to the quantified value of a key influencing factor, and the overall representation is the state fingerprint of the device at this moment.

[0039] Step S102: Input the current multidimensional state vector into the pre-constructed multidimensional state space for node matching, determine the current state node, and extract the set of basic hardware control parameters bound to the current state node;

[0040] The multidimensional state space consists of multiple state nodes formed by clustering historical state vectors, and the spatial distribution of each state node represents the coupling constraint relationship between power, temperature, network quality and task load.

[0041] Specifically, the multidimensional state space is a discretized space formed by clustering a large number of multidimensional state vectors accumulated during the historical operation of the device (such as the K-means algorithm). Each state node corresponds to a cluster center, and its spatial location is defined by the mean coordinates of all historical vectors in the cluster. Moreover, this location contains the coupling constraint relationship between power, temperature, network quality (signal strength, packet loss rate), and task load (processor load rate, acceleration indicator). For example, high load is often accompanied by high temperature and low power, and the node location will cluster in the multidimensional space to reflect this relationship.

[0042] In this embodiment, the node matching process can employ Euclidean distance: by calculating the distance between the current vector and the coordinates of all nodes, the node with the smallest distance is the current state node, representing the historical typical scenario closest to the current state. By extracting the set of basic hardware control parameters bound to this node (the average of historical hardware parameters within the cluster, such as CPU frequency, communication power, and sleep cycle), it serves as a benchmark reference for subsequent adjustments, thereby mapping the unknown dynamic state to a known experience framework and avoiding decision-making from scratch.

[0043] Step S103: Obtain multiple adjacent nodes of the current state node in the multidimensional state space;

[0044] The selection of adjacent nodes follows the principle of experience transfer from neighboring states. In the multidimensional state space, other nodes whose spatial distance from the current state node is less than the Euclidean distance threshold are filtered by a preset neighborhood radius (such as an Euclidean distance threshold) to form a set of adjacent nodes.

[0045] Understandably, these nodes represent historical scenarios that are similar to but slightly different from the current state (for example, the current node represents "medium load + normal temperature + good signal", while adjacent nodes may include "medium load + slight heat + good signal" or "medium load + normal temperature + signal fluctuation"). Their historical state transition paths contain experience in parameter fine-tuning, providing a nearby reference system for predicting parameter adjustment trends under the current state.

[0046] Step S104: Extract the state transition paths of multiple neighboring nodes within the historical time period, and calculate the parameter offset trend vector for the current state node based on the state transition paths.

[0047] The core of this step is to predict dynamic trends from nearby historical evolution. The state transition path refers to the trajectory of adjacent nodes moving from one state node to another in the historical time series (such as "node A → node B → node C" representing the process of gradually adjusting parameters within a certain period).

[0048] In the embodiments of this application, when calculating the parameter offset trend vector, the state vector sequence of adjacent nodes in a continuous time window (such as the past 10 sampling periods) is first extracted, and the difference between adjacent vectors is calculated in time order (reflecting the direction and magnitude of a single adjustment). Then, these difference vectors are weighted and summed. The weight design follows the principle of "the more recent time has a greater impact" (such as the weight of the previous window is 0.5, the previous 2 is 0.3, and the previous 3 is 0.2).

[0049] Ultimately, the calculated parameter offset trend vector provides a dynamic guide to "which direction and with what intensity the parameters should be adjusted." For example, if neighboring nodes generally shift from "low load" to "medium load" accompanied by a 5% increase in CPU frequency, the trend vector will include this upward adjustment component.

[0050] Step S105: The basic hardware control parameter set and the parameter offset trend vector are fused to generate the target hardware control instruction set, which is then sent to the hardware driver layer for adjustment.

[0051] Specifically, firstly, the components of each dimension of the parameter offset trend vector are converted into adjustment amounts of the basic hardware control parameter dimensions (such as CPU frequency adjustment amount and communication power adjustment amount) through a preset dimension mapping matrix. Then, the adjustment amount is superimposed on the corresponding value of the basic hardware control parameter set (such as basic frequency 2.0GHz + trend vector + 0.2GHz) to form preliminary adjustment parameters. Subsequently, hardware physical boundary limiting processing is performed to ensure that the instructions are executable by eliminating values ​​that exceed the hardware allowable range (such as CPU frequency lower limit 1.0GHz, upper limit 3.0GHz, and boundary value is taken if the limit is exceeded).

[0052] Finally, the generated target hardware control instruction set (such as "CPU frequency 2.2GHz, communication module power 5dBm, sleep interval 10ms") is sent to the hardware driver layer to directly regulate the power consumption-related modules at the device's bottom layer, thereby achieving on-demand power supply.

[0053] Step S106: Collect the actual energy consumption data and actual state parameters after hardware adjustment, and calculate the execution deviation value for the current state node;

[0054] Among them, the actual energy consumption data (such as power consumption per unit time) after the adjustment is collected and the actual status parameters (including actual environmental parameters and actual equipment operating parameters) are compared, and the adjustment effect is evaluated by calculating the execution deviation value.

[0055] Specifically, the energy consumption is compared with the target energy consumption (ideal value estimated based on basic parameters and trend vectors) when the command is issued to obtain an energy consumption error value (reflecting the degree of achievement of the energy-saving target); the actual state parameters are used to generate a feedback multidimensional state vector according to the encoding rules in step S101, and the Euclidean distance between the actual state parameters and the original current multidimensional state vector is calculated as the state deviation value (reflecting whether the adjusted state deviates excessively from the original scenario). Subsequently, the two are weighted and fused (e.g., energy consumption error accounts for 60%, state deviation accounts for 40%) to form an execution deviation value, which comprehensively characterizes whether the adjustment is effective and stable.

[0056] Step S107: Based on the execution deviation value, the spatial position coordinates of the current state node and adjacent nodes in the multi-dimensional state space are offset and corrected, and the bound basic hardware control parameter set is updated.

[0057] Specifically, based on the execution deviation value, the coordinates of the current state node are adjusted by moving in the opposite direction of the gradient (if the deviation is positive, it indicates over-adjustment, and the node moves in the direction with lower energy consumption). The movement step size is controlled by a preset learning rate (to avoid oscillations). At the same time, the movement amount of the current node is distributed to the neighboring nodes in proportion to the inverse of the spatial distance (the closer the distance, the more is distributed), so that the neighboring nodes are fine-tuned synchronously to maintain the topological consistency of the state space (to avoid local corrections from destroying the overall association).

[0058] After the correction is completed, the set of basic hardware control parameters bound to the node is recalculated (updated with the average of historical parameters corresponding to the new coordinates), and the effective experience of this adjustment is solidified into the state space so that more accurate parameters can be called when matching similar states in the future.

[0059] In the above implementation, historical experience is structured using a multi-dimensional state space as a carrier, dynamic changes are captured by adjacent node trend prediction, precise power consumption adjustment is achieved by fusing basic parameters and offset trends, and self-evolution is achieved by reverse correction of the state space through execution deviation. Ultimately, this improves the power efficiency, environmental adaptability, and long-term operational stability of IoT devices in complex and ever-changing environments, solves the pain point that traditional static strategies or single-parameter feedback control cannot cope with the dynamic changes of multiple coupled factors, and provides core technical support for energy saving and reliable operation of IoT devices.

[0060] Reference Figure 2 As one implementation of step S101, the step of acquiring and encoding the real-time environmental parameters and device operating parameters of the IoT device to generate the current multi-dimensional state vector includes:

[0061] Step S201: The physical environment parameters and device operating parameters are collected in real time through the sensor array built into the IoT device; the real-time environmental parameters include temperature data, acceleration data and signal strength data, and the device operating parameters include battery remaining power data, processor load rate data and packet loss rate data.

[0062] Specifically, the power consumption of IoT devices is not determined by a single factor, but is the result of the coupling effect of physical environment (such as temperature changes affecting chip heat dissipation efficiency and leakage current, and acceleration changes indicating device movement or task triggering) and operating status (such as battery remaining power limiting the upper limit of energy supply, processor load rate reflecting computational density, and signal strength and packet loss rate related to the retransmission power consumption of communication modules).

[0063] Therefore, a sensor array can be selected as the data acquisition terminal: a temperature sensor monitors the ambient or chip temperature, an accelerometer captures sudden changes in device motion, a power monitoring chip reads the remaining battery power in real time, and a network communication module (integrating signal strength detection and packet loss statistics) acquires network quality parameters. By transforming the originally scattered implicit states into quantifiable explicit data, raw materials are provided for subsequent encoding processing, ensuring the comprehensiveness of state representation. For example, acceleration data can reveal whether the device has entered an "emergency task mode" (such as sudden movement detection), while the synchronous acquisition of signal strength and packet loss rate can reflect the dynamic impact of network fluctuations on communication power consumption.

[0064] Step S202: Based on a preset dimensional ratio, the temperature data, signal strength data, and remaining battery power data are standardized to generate a normalized parameter set.

[0065] Among them, parameters such as temperature (unit: °C), signal strength (unit: dBm), and remaining battery power (unit: %) cannot be directly used in subsequent distance calculations or cluster analysis in the state space due to differences in their dimensions and value ranges.

[0066] Therefore, standardization can be implemented by setting a preset dimension ratio: set a reasonable reference range for each parameter (e.g., temperature is taken as the device's operating range of -20℃ to 80℃, signal strength is taken as -100dBm to 0dBm, and power is taken as 0% to 100%), and compress the original value to a unified dimensionless range (e.g., [0,1]). Specifically, the minimum and maximum thresholds of each parameter can be set, and the standardized value can be calculated according to the formula: Standardized value = (Original value - Minimum threshold) / (Maximum threshold - Minimum threshold), and the output parameter set in the range of [0,1] can be output.

[0067] Next, after eliminating unit differences, the contribution weights of different parameters to the state space can be naturally balanced through subsequent algorithms (such as clustering), avoiding the "submergence" of some parameters due to large differences in numerical magnitude. For example, the change in battery charge from 20% to 80% (a span of 60%) and the change in signal strength from -90dBm to -30dBm (a span of 60dBm), after standardization, are both converted into values ​​in the range of 0 to 1, which can participate equally in node matching in multidimensional space, ensuring the objectivity of state representation.

[0068] Step S203: Perform abrupt event detection on the acceleration data and generate a task urgency indicator;

[0069] This step aims to capture state warning signals of discontinuous dynamic events. Acceleration data itself reflects the motion state of the device, but continuous and stable acceleration (such as being stationary or moving at a constant speed) has a limited impact on power consumption. However, drastic changes in a short period of time (such as the device being picked up or suddenly turning) often indicate a change in the nature of the task (such as switching from standby to emergency monitoring). At this time, it is necessary to temporarily improve performance (such as increasing the CPU frequency or activating the sensor), which leads to a sudden increase in power consumption.

[0070] In this embodiment of the application, the mutation event detection calculates the variance of acceleration data (to measure the degree of data fluctuation) by setting a time window (such as the most recent 500ms). If the variance exceeds the preset mutation threshold (such as the upper limit of the 95% confidence interval based on historical data statistics), it is determined to be an "emergency task scenario" and outputs the "highest level task urgency indicator" (such as "1"); otherwise, it is a "normal task scenario" and outputs the "normal level indicator" (such as "0").

[0071] Understandably, by converting continuous acceleration data into discrete "event tags," the sudden states that steady-state parameters (such as load rate) cannot characterize are supplemented, enabling subsequent state nodes to distinguish between two different power consumption demand modes: smooth operation and emergency response.

[0072] Step S204: Perform interval mapping processing on the processor load rate data and packet loss rate data, and output a discretized set of operating parameters;

[0073] The logic of this step is to reduce the redundancy of the state space of continuous parameters. Although the processor load rate (0%~100%) and packet loss rate (0%~100%) are continuous values, the impact of slight fluctuations (such as load rate from 51% to 52%) on power consumption in actual operation is much smaller than that of cross-range changes (such as from 40% to 60%).

[0074] Therefore, the load rate can be discretized through interval mapping: the processor load rate is divided into five levels in 10% intervals (e.g., 0%-10% is mapped to 1, 11%-20% to 2, and so on up to 41%-50% to 5, with higher loads being merged into the 5th level), and the packet loss rate is divided into four levels in 5% intervals (e.g., 0%-5% is mapped to 1, 6%-10% to 2, and so on). This discretization mechanism preserves key trends (e.g., a high load rate means a significant increase in power consumption) while avoiding state node explosion caused by excessive subdivision (if the load rate has 100 discrete values, the state space dimension will expand dramatically). For example, a load rate of 65% is mapped into the "61%-70%" level (assuming the five levels are divided up to the 5th level for loads above 50%), simplifying it into a single level value, making subsequent clustering analysis more efficient.

[0075] Step S205: The normalized parameter set, task urgency identifier and discretized running parameter set are concatenated in a preset dimensional order to output the current multidimensional state vector.

[0076] Specifically, these segments can be sequentially concatenated using a preset dimensional order (such as "normalized temperature value - normalized remaining battery power value - task urgency indicator - normalized signal strength value - discrete processor load rate value - discrete packet loss rate value") to form a fixed-dimensional vector. Each dimension of this vector corresponds to a quantitative representation of a core influencing factor, and the whole vector constitutes a unique identifier of the device's current state.

[0077] For example, the vector [0.3,0.6,1,0.8,4,2] can be interpreted as "moderate temperature (0.3), sufficient battery (0.6), urgent task (1), good signal (0.8), high load (level 4), low packet loss rate (level 2)". This structured output provides a standardized query input for subsequent node matching in the multidimensional state space, ensuring that the states of different devices at different times can be compared and classified within the same framework. In addition, if there are outlier parameters in the current multidimensional state vector, the outlier values ​​are replaced with backup parameters from similar historical scenarios to generate a corrected multidimensional state vector.

[0078] In the above implementation, a sensor array is used to collect all parameters, dimensional standardization is used to eliminate unit barriers, abrupt change detection is used to supplement sudden state labels, interval mapping is used to compress continuous parameter redundancy, and finally, the current multidimensional state vector with comprehensiveness and computability is generated by sequential splicing. This lays a precise state characterization foundation for the adaptive dynamic power consumption adjustment of IoT devices and improves the reliability of subsequent state matching and parameter adjustment.

[0079] Reference Figure 3 As one implementation of the multidimensional state space in step S102, the steps for constructing the multidimensional state space include:

[0080] Step S301: Obtain multiple historical multidimensional state vectors and corresponding historical hardware control parameters of the IoT device during its historical operating cycle;

[0081] The core logic of this step lies in building an empirical data foundation for the state space. By mining the full amount of historical data of the equipment, a real-scenario sample library is provided for subsequent state abstraction.

[0082] Specifically, the power consumption adjustment of IoT devices needs to adapt to complex dynamic environments, and historical data implicitly contains the causal relationship between "state and control": historical multidimensional state vectors are quantitative representations generated by the device's past sensor data (such as temperature, remaining battery power, signal strength, processor load rate, etc.) according to preset encoding rules (such as normalization, discretization), covering the coupled state of environmental parameters (temperature, network quality) and operating parameters (power, task load); historical hardware control parameters are the power consumption adjustment instructions actually executed in the corresponding state (such as processor frequency adjustment value, communication module power setting, peripheral device sleep cycle, etc.), recording the response strategy to specific states.

[0083] The process of acquiring this data essentially transforms the past operating status and control experience of the equipment into calculable digital assets, ensuring that the state space subsequently constructed is rooted in real-world scenarios rather than theoretical assumptions.

[0084] Step S302: Spatial division of multiple historical multidimensional state vectors is performed using a clustering algorithm to generate multiple cluster center points, and each cluster center point is used as a state node;

[0085] The core logic of this step is to reduce the dimensionality of high-dimensional heterogeneous state data into interpretable discrete typical state units. Because the state vectors of IoT devices have high dimensionality (such as containing multiple parameters such as temperature, power, and load), direct processing can easily lead to the "curse of dimensionality." Clustering algorithms (such as K-means or DBSCAN density clustering) can automatically group similar state vectors through iterative calculations. The distance between vectors within each group is less than the distance between groups, and the cluster center (the mean coordinate of all vectors within the group) is the representative state of that group.

[0086] Next, by defining these center points as state nodes, each node corresponds to a "historical prototype of similar states." For example, all state vectors representing "moderate load + normal temperature + good signal" will be clustered into one class, and the cluster center point is the node location of that class of states. The spatial coordinates of the nodes are jointly determined by multi-dimensional parameters, implying the coupling constraints between power, temperature, network quality, and task load (e.g., high load is often accompanied by high temperature and low power, and nodes will cluster in multi-dimensional space to reflect this correlation), providing a structured empirical index for subsequent state matching.

[0087] Step S303: Calculate the average of the historical hardware control parameters belonging to the same state node, and output the average set as the basic hardware control parameter set for binding the state node.

[0088] The logic of this step focuses on extracting the optimal empirical consensus under similar conditions. Historical hardware control parameters under the same cluster node are records of multiple adjustments made by the device in similar past states (e.g., when a node corresponds to a "low load + low temperature" state, it may have executed instructions such as "CPU frequency 1.2GHz, communication power 3dBm"). Generating a basic set of hardware control parameters through mean calculation essentially uses the central tendency to represent the generally effective strategy under this type of state. This filters out random errors from single adjustments (such as parameter fluctuations caused by temporary interference) while retaining adaptability for most scenarios (e.g., a CPU frequency of 1.2GHz can achieve energy efficiency balance under most "low load" states).

[0089] Understandably, by using this set of basic hardware control parameters as an inherent attribute of the node, it can be directly used as a benchmark for adjustment when the device enters a similar state again, avoiding decision-making from scratch and improving response efficiency.

[0090] Step S304: Calculate the spatial distance between different state nodes, and establish bidirectional connections between state nodes whose spatial distance is less than the preset neighborhood radius to establish adjacency relationships between state nodes.

[0091] The logic behind this step lies in constructing neighboring experience transfer channels in the state space. The spatial distance between state nodes (e.g., Euclidean distance) is used to measure the similarity of their representative states: the smaller the spatial distance, the closer the historical states of the two nodes are (e.g., the distance between a "medium load + normal temperature" node and a "medium load + slightly hot" node is smaller than its distance to a "high load + high temperature" node). By setting a preset neighborhood radius (e.g., a distance threshold), neighboring nodes similar to the current node are selected, and adjacency relationships are established through bidirectional connections, meaning these nodes constitute a cluster of similar states.

[0092] Understandably, by establishing adjacency relationships, when a device is in a certain node state, it can refer to the historical transfer paths of its neighboring nodes (such as adjustment experience from "medium load" to "high load") to predict the parameter adjustment trend in the current state, realize the migration of neighboring experience, and make up for the limitations of single node experience.

[0093] In the above embodiments, this multidimensional state space construction method uses historical operating data as samples, reduces high-dimensional states to discrete nodes through clustering algorithms, solidifies the optimal experience of similar states using a mean parameter set, and establishes experience transfer channels for similar states through adjacency relationships, ultimately forming a structured and evolvable "state-experience" mapping space. This mapping space transforms fragmented historical control experience into a computable knowledge graph, providing accurate state matching benchmarks and dynamic trend prediction basis for adaptive power consumption adjustment of IoT devices. It improves the adaptability, accuracy, and long-term effectiveness of power consumption strategies in complex environments, and solves the problems of control lag and poor scenario adaptability caused by traditional methods relying on static rules or single-state memory.

[0094] Reference Figure 4 As one implementation of step S102, the steps of inputting the current multidimensional state vector into a pre-constructed multidimensional state space for node matching, determining the current state node, and extracting the basic hardware control parameter set bound to the current state node include:

[0095] Step S401: Calculate the spatial Euclidean distance between the current multidimensional state vector and each state node in the multidimensional state space;

[0096] The core logic of this step lies in establishing a relationship between "current state and typical historical state" based on quantitative similarity. The current multidimensional state vector is the fingerprint of the device's current operating state (such as a structured vector that integrates parameters such as temperature, power, and load), while the state nodes in the multidimensional state space are typical state prototypes formed by historical clustering (each node corresponds to the spatial coordinates of a class of similar historical states).

[0097] In this embodiment, spatial Euclidean distance, a classic metric for measuring the difference between two points in high-dimensional space, is used to comprehensively reflect the overall differences in multidimensional parameters by calculating the straight-line distance between the current vector and the coordinates of each node. For example, if the temperature dimension of the current vector is 0.1 higher than that of node A and the electricity dimension is 0.2 lower, these differences are accumulated by summing the square roots of the squares of the Euclidean distances, ultimately outputting a numerical value representing the degree of similarity. The smaller the Euclidean distance, the closer the current state is to the historical typical state of that node, and the higher the accuracy of subsequent matching.

[0098] Step S402: Determine whether the smallest spatial Euclidean distance among multiple spatial Euclidean distances is greater than a preset abnormal distance threshold; if yes, proceed to step S403; otherwise, proceed to step S404.

[0099] Among them, the preset abnormal distance threshold is a similarity threshold set based on historical data statistics (such as taking the 95th percentile of all historical minimum distances), which is used to determine whether the current state is within the coverage of the existing state space.

[0100] In this embodiment, if the minimum Euclidean distance is still greater than the threshold, it indicates that the current state is dissimilar to all known typical states. For example, historical nodes often represent "normal temperature + medium load," while the current state is "high temperature + extreme load," and the difference between the two far exceeds the threshold, belonging to an unknown scenario that has never appeared before. If the minimum distance is less than or equal to the threshold, it indicates that the current state belongs to a known scenario, and historical experience can be reused. This step is to define path branches for subsequent processing, avoiding the use of known experience to deal with completely unfamiliar states, or the use of new nodes to deal with scenarios that could be reused.

[0101] Step S403: Based on the spatial coordinates of the current multidimensional state vector, generate a new state node in the multidimensional state space as the current state node, and read the historical state node determined by the pre-cached historical control cycle, and configure the historical basic hardware control parameter set bound to the historical state node as the basic hardware control parameter set bound to the current state node.

[0102] Specifically, when the judgment result is "yes", the processing logic can be extended around the fault tolerance of unknown scenarios. First, a new state node is generated based on the spatial coordinates of the current multidimensional state vector. The current vector is directly used as the spatial coordinates of the new node, which means that the new node is a "digital representation of the current unknown state" and fills the gap in the state space.

[0103] Secondly, the historical state node determined by the pre-cached historical control cycle (usually the current state node of the previous moment, as it is the most recent known experience) is read, and its historical basic hardware control parameter set is configured as the initial parameters of the new node.

[0104] Understandably, unknown scenarios are not entirely unpredictable. The previous state is the most recent known state. Initializing a new node with its parameters avoids the blind start-up of a new node from scratch and maintains the device's control inertia (e.g., if the previous CPU frequency was 1.5GHz to handle a similar load, the new node will also use this value initially). For example, if the device suddenly enters the unknown state of "emergency monitoring" from "standby," the new node will be initialized with the standby state parameters, and then corrected through feedback to ensure the continuity of control.

[0105] Step S404: Take the state node corresponding to the minimum spatial Euclidean distance as the current state node, and extract the basic hardware control parameter set bound to the current state node.

[0106] Specifically, when the judgment result is "no", the processing logic can focus on the reuse of experience in known scenarios. The state node corresponding to the minimum Euclidean distance is taken as the current state node because it represents the historical typical scenario most similar to the current state (e.g., the current state is "medium load + slight heat", and the minimum distance node is the typical state of "medium load + normal temperature").

[0107] Next, the basic hardware control parameter set bound to the node is extracted (the average set of historical parameters of the same node during clustering). Essentially, this uses the optimal empirical consensus of similar states as the benchmark starting point for current power consumption adjustment. For example, if the node's parameter set is "CPU frequency 1.2GHz, communication power 3dBm," it indicates that these parameters have historically achieved energy efficiency balance under most "medium load" conditions. This step avoids the overhead of making decisions from scratch, directly adapting historically validated strategies to the current state, thus improving the efficiency and accuracy of regulation.

[0108] In the above implementation, precise node matching is achieved using spatial Euclidean distance as a similarity metric. A preset abnormal distance threshold is used to divide known and unknown scenarios. New nodes are dynamically created for unknown scenarios, inheriting the most recent historical experience. Basic parameters of typical states are reused for known scenarios, forming a node matching and parameter extraction mechanism that accurately reuses known scenarios and fault-tolerantly expands for unknown scenarios. This mechanism ensures the adaptability of the multi-dimensional state space to the dynamic environment, providing a reliable state-parameter mapping basis for subsequent power consumption adjustment, and improving the stability, generalization ability, and long-term operational reliability of IoT devices' adaptive dynamic power consumption adjustment.

[0109] Reference Figure 5 As one implementation of step S104, the step of extracting the state transition paths of multiple neighboring nodes within a historical time period and calculating the parameter offset trend vector for the current state node based on the state transition paths includes:

[0110] Step S501: Extract the historical state vector sequence of multiple neighboring nodes within multiple consecutive time windows before the current time from the historical log database.

[0111] The historical log database is a continuous "state-time" archive recorded during device operation, storing multi-dimensional state vectors (such as quantified values ​​of parameters like temperature, power, and load) for each state node (including adjacent nodes) at different times. Adjacent nodes are other nodes in the multi-dimensional state space that are spatially close to the current state node, representing similar but slightly different historical scenarios (e.g., the current node represents "medium load + normal temperature," while adjacent nodes may include "medium load + slight heat" or "low load + normal temperature").

[0112] In this embodiment, the historical state vector sequence of these nodes within multiple consecutive time windows prior to the current moment (e.g., the past 10 sampling periods, with window length configured according to device type: 5 seconds for industrial equipment, 1 second for consumer electronics) is extracted to capture the state transition trajectory of adjacent nodes from the past to the present. For example, if an adjacent node has a "low load + low temperature" vector in window 1, a "medium load + normal temperature" vector in window 2, and a "medium load + slight heat" vector in window 3, its sequence records the gradual change of load and temperature over time.

[0113] Step S502: Arrange the historical state vector sequence in chronological order to generate multiple state transition paths of neighboring nodes within the historical time period, and calculate the difference between the historical state vectors of adjacent time windows in the state transition path to generate multiple state difference vectors.

[0114] Among them, the historical state vectors of adjacent time windows are continuous snapshots of states arranged chronologically, such as the vector Vt for window t and the vector Vt+1 for window t+1. The state difference vector is calculated by subtracting the vector of the previous window from the vector of the next window (i.e., ΔV = Vt+1 - Vt). Each of its dimensional components corresponds to the change of a parameter (such as the rate of temperature increase, the rate of power consumption, and the magnitude of load increase or decrease), and the whole represents "the direction and step size of the state's movement in multidimensional space from time t to time t+1".

[0115] For example, if a neighboring node has a load rate of 20% in window 1 (vector component 0.2) and 40% in window 2 (component 0.4), the difference in load rate dimension is +0.2, reflecting an increase in load; if the temperature rises from 25℃ (normalized 0.25) to 30℃ (0.3), the difference is +0.05, reflecting an increase in temperature. Calculating the state difference vector of all adjacent windows in chronological order can reconstruct the continuous chain of changes in the state evolution of adjacent nodes, providing "step-level" detail for trend analysis.

[0116] Step S503: Obtain the preset time decay weight configuration parameters, perform time decay weighting processing on the state difference vector, and generate a weighted difference vector set;

[0117] Among the time decay weight configuration parameters, the weight of the time window that is closer to the current time is greater;

[0118] Specifically, the core of this step is to highlight the dominant influence of recent changes on current decisions. The logic stems from the objective law of state inertia in dynamic systems. The evolution of equipment state is usually continuous, and the direction of recent adjustments is more likely to continue to the present moment.

[0119] In this embodiment, the time decay weighted processing assigns differentiated weights to the difference vectors at different time points. By setting the current time as the benchmark, the difference vectors closer to the current time (such as the changes in the last time window) are given higher weights, while the difference vectors further away (such as the changes in the earliest window) have lower weights. Specifically, the weight coefficients can be calculated using the formula "weight = 1 / (1 + time distance)".

[0120] For example, if the sequence of difference vectors between adjacent nodes is ΔV1 (10 seconds ago), ΔV2 (5 seconds ago), and ΔV3 (1 second before the current moment), the weights can be designed according to the "recency effect" as 0.2, 0.3, and 0.5 (summing up to 1), maximizing the contribution of the change in ΔV3 to the trend. It is understandable that earlier state transitions may have been overridden by subsequent adjustments or become invalid due to environmental changes, while recent changes better reflect the true adjustment logic under the current dynamics, avoiding interference from outdated experience.

[0121] Step S504: The weighted difference vector set is superimposed to generate a parameter offset trend vector.

[0122] In this set of weighted difference vectors, each vector carries the direction, magnitude and time weight of a single change. The vector superposition is achieved by algebraically summing the components of each dimension (such as adding the CPU frequency change and communication power change of all vectors). After superposition, the vectors are normalized so that the magnitude of the output vector does not exceed a preset threshold, thereby integrating these scattered "step-level changes" into a parameter offset trend vector.

[0123] Specifically, each component of the parameter offset trend vector corresponds to a comprehensive adjustment tendency of a hardware control parameter: a positive value indicates that the parameter should be increased (e.g., CPU frequency should be increased), a negative value indicates that it should be decreased (e.g., communication power should be reduced), and the absolute value reflects the adjustment intensity. For example, if multiple neighboring nodes have recently shown a weighted difference of "CPU frequency increased by 0.1GHz when load increases," the superimposed trend vector will show a positive component in the CPU frequency dimension, suggesting that if the load increases in the current state, the frequency can be adjusted with reference to this trend. This process extracts common trends from the evolution of neighboring historical groups, thereby providing a data-driven predictive basis for the dynamic adaptation of the current state.

[0124] In the above implementation, the historical state transition paths of adjacent nodes are used as samples. Dynamic evolution is captured by extracting the sequence of continuous time windows. The difference vector is used to quantify a single state transition. The time decay weighting is used to highlight the dominance of recent changes. Finally, a comprehensive adjustment trend is generated by vector superposition, realizing a logical closed loop from neighboring experience to dynamic prediction.

[0125] In practical applications, this technical solution addresses the shortcomings of traditional trend prediction, which ignores time weight and relies on the experience of a single node. It makes parameter adjustments more in line with the dynamic characteristics of the current state, providing accurate trend guidance for the adaptive power consumption adjustment of IoT devices in complex environments and improving the foresight and adaptability of power consumption strategies.

[0126] Reference Figure 6 As one implementation of step S105, the step of fusing the basic hardware control parameter set and the parameter offset trend vector to generate the target hardware control instruction set includes:

[0127] Step S601: Superimpose the components of each dimension of the parameter offset trend vector onto the corresponding parameter values ​​of the basic hardware control parameter set to generate the superimposed parameter set.

[0128] Among them, the basic hardware control parameter set is the historical experience consensus (such as the mean set of historical hardware parameters within the same cluster) bound to the current state node (or newly created node) in the multi-dimensional state space. It includes the benchmark values ​​of core control parameters such as processor frequency, communication protocol type, and peripheral device status (e.g., CPU frequency 2.0GHz, communication power 5dBm), representing the general effective strategies under the same state.

[0129] The parameter offset trend vector is a dynamic adjustment guide extracted from the historical state transition paths of adjacent nodes (such as predicted changes in various dimensions, CPU frequency +0.2GHz, communication power -0.5dBm), reflecting the common adjustment direction of similar states in recent evolution.

[0130] In this embodiment, the essence of the overlay process is to inject the change in the trend vector into the static value of the baseline parameter, and then update the parameter through algebraic addition. For example, in the basic hardware control parameter set, a CPU frequency of 2.0 GHz is overlaid with a trend vector of +0.2 GHz to generate an updated value of 2.2 GHz. This step logic respects the validity of historical experience (based on the baseline value) while incorporating the immediate needs of dynamic scenarios (using the trend vector as a correction), making parameter adjustment both stable and adaptable.

[0131] In addition, when an abnormal jump value is detected in the superimposed parameter set, the historical stable parameter set is called for smooth replacement, and the optimized parameter set is output for instruction conversion.

[0132] Step S602: Perform physical boundary constraint processing on the superimposed parameter set, remove values ​​that exceed the hardware's allowable operating range, and output the parameter set after amplitude limiting.

[0133] The hardware's permissible operating range is the physical limit of the device's underlying hardware (such as a minimum CPU frequency of 1.0 GHz and a maximum of 3.0 GHz, and a minimum communication power of 0 dBm and a maximum of 10 dBm), which is predefined by the chip manual or actual measurement data.

[0134] Specifically, the limiting process includes: traversing each dimension of the superimposed parameter set; if the parameter value is less than the minimum threshold (e.g., a CPU frequency of 1.8GHz becomes 0.9GHz after superposition), it is corrected to the minimum threshold of 1.0GHz; if it is greater than the maximum threshold (e.g., communication power becomes 12dBm after superposition), it is corrected to the maximum threshold of 10dBm. For example, if the processor frequency in a certain superimposed parameter set is 3.2GHz (exceeding the maximum threshold of 3.0GHz), the limiting value is set to 3.0GHz, preserving the positive adjustment intention of the trend without exceeding hardware limits, thus achieving a balance between security and performance.

[0135] Step S603: Convert the parameter set after the limiting process into a hardware-executable instruction format to generate the target hardware control instruction set.

[0136] The parameter set after the limiting process is an optimized set of parameters that have been verified for safety (such as CPU frequency 2.2GHz, communication power 4.5dBm, and peripheral device sleep interval 10ms). However, these values ​​need to be converted into instruction formats that the hardware driver layer can recognize (such as register address + write value, configuration word, and API call parameters).

[0137] In this embodiment, the conversion logic can be based on hardware interface specifications: for example, CPU frequency adjustment requires writing binary code to a specific register (2.2GHz corresponds to 0x1F), communication power setting requires calling the configuration function of the baseband chip (parameter 4.5dBm is mapped to command word 0x45), and peripheral device status control requires triggering the high and low levels of GPIO pins. This process ensures that abstract parameter values ​​are converted into specific hardware operations, enabling the target hardware control instruction set to directly drive the underlying modules of the device (such as CPU speed controllers and communication module power amplifiers) to perform power consumption adjustment.

[0138] In the above implementation, benchmark experience and dynamic trends are superimposed to achieve precise adaptation, hardware security is ensured based on physical boundary constraints, and execution is achieved through instruction format conversion. This technology retains the effectiveness of historical regulation while incorporating the immediate needs of dynamic scenarios. At the same time, it avoids hardware risks through amplitude limiting processing. The final target hardware control instruction set is accurate, secure, and executable, improving the response efficiency and long-term operational reliability of IoT devices' adaptive dynamic power consumption adjustment.

[0139] Reference Figure 7As one implementation of step S106, the step of collecting actual energy consumption data and actual state parameters after hardware adjustment, and calculating the execution deviation value for the current state node includes:

[0140] Step S701: Collect actual energy consumption data and actual status parameters after hardware adjustment through the sensor array built into the IoT device;

[0141] Specifically, the sensor array is the key sensing terminal for realizing the "execution-feedback" cycle: the energy consumption monitoring unit (such as the current sensor) collects the actual energy consumption data after hardware adjustment (such as the current value and power value per unit time), which directly reflects the real power consumption cost of the control command; the environmental sensor array (such as the temperature sensor and accelerometer) collects the actual environmental parameters (such as the adjusted chip temperature, changes in device acceleration, and signal strength fluctuations); the power monitoring chip reads the remaining battery power; the network communication module (integrating signal strength detection and packet loss statistics functions) obtains network quality parameters; and the load monitoring module obtains the processor load rate.

[0142] Step S702: Extract the corresponding target energy consumption data from the target hardware control instruction set, and calculate the energy consumption error value based on the actual energy consumption data and the target energy consumption data.

[0143] Among them, the target hardware control instruction set is an ideal control scheme that integrates basic parameters and trend vector generation. The target energy consumption data is the unit time energy consumption value estimated based on historical operating data when the target hardware control instruction set is issued. For example, the unit time power consumption estimated based on historical experience when issuing the instruction, such as "the CPU frequency should consume 100mA when the CPU frequency is 2.2GHz".

[0144] The calculation of the energy consumption error value involves subtracting the actual energy consumption data (e.g., the adjusted measured 110mA) from the target energy consumption data (110mA - 100mA = +10mA). The sign of the error value reflects whether the actual energy consumption exceeds expectations (positive for overspending, negative for savings), and the absolute value reflects the degree of deviation. For example, if the target energy consumption is a 20% reduction, but the actual reduction is only 5%, the energy consumption error value will reveal this gap, providing a target-oriented basis for subsequent adjustments.

[0145] Step S703: After encoding the actual state parameters, a feedback multidimensional state vector is generated, and the state deviation distance between the feedback multidimensional state vector and the current multidimensional state vector is calculated.

[0146] The encoding process must employ the same rules as those used to generate the "current multidimensional state vector," transforming actual environmental parameters into a feedback multidimensional state vector (e.g., a vector showing "temperature 0.4, battery level 0.5, task urgency 0, signal strength 0.7, load rate 3, packet loss rate 2" after adjustment). The current multidimensional state vector is the "original state fingerprint" before adjustment. The state deviation distance is calculated using metrics such as Euclidean distance (e.g., the straight-line distance between the feedback vector and the original vector), reflecting the degree to which the adjusted state deviates from the original scenario.

[0147] For example, if the original state is "low load + normal temperature", and the temperature rises to "slightly warm" due to the increase in CPU frequency after adjustment, the temperature dimension of the feedback vector will change from 0.2 to 0.4, the state deviation distance will increase, and the message "the adjustment may have affected the stability of the environment" will be displayed.

[0148] Step S704: Obtain the preset weight configuration parameters, and perform weighted fusion of energy consumption error value and state deviation distance to generate execution deviation value.

[0149] The preset weight configuration parameters are dynamically set according to the device type. For example, industrial equipment focuses on temperature stability, and the weight is tilted towards the state deviation distance; consumer electronics focus on network experience, and the weight is tilted towards the signal dimension. The energy consumption error value (reflecting the degree of achievement of energy-saving goals) and the state deviation distance (reflecting state stability) are combined according to their weights (e.g., the energy consumption error weight is 0.3 and the state deviation weight is 0.7 in industrial equipment) to generate the execution deviation value.

[0150] The specific calculation formula is: Execution deviation value = Σ(dimensional difference_i × weight_i) + energy consumption integral value × energy consumption weight, where the sum of all weight coefficients is 1.

[0151] Understandably, if only energy consumption error is considered, excessively reducing CPU frequency to save energy might lead to task lag (large state deviation); if only state deviation is considered, energy-saving opportunities might be sacrificed for stability. After weighted fusion, the execution deviation value can comprehensively reflect whether the adjustment has achieved a balance between energy saving and stability, thus providing global feedback for subsequent state space correction.

[0152] In the above implementation, a sensor array is used to collect real execution results. The energy-saving effect is quantified by the difference between the target energy consumption and the actual energy consumption. The stability of the state is evaluated based on the deviation between the feedback vector and the original vector. Finally, a comprehensive execution deviation value is generated through weighted fusion. This technical solution solves the one-sidedness problem of traditional single-index evaluation, provides a precise correction basis for the self-evolution of multi-dimensional state space, ensures that the adaptive dynamic power consumption adjustment of IoT devices continuously optimizes between "energy saving" and "functional stability", and improves the accuracy of regulation and the long-term operational reliability in complex environments.

[0153] Reference Figure 8 As one implementation of step S107, the steps of offsetting and correcting the spatial position coordinates of the current state node and adjacent nodes in the multi-dimensional state space according to the execution deviation value, and updating the bound basic hardware control parameter set include:

[0154] Step S801: Map the execution deviation value to the spatial coordinate dimension of the multi-dimensional state space to generate a dimension deviation vector;

[0155] Among them, the execution deviation value is a comprehensive index generated by weighted fusion of energy consumption error and state deviation distance. It comprehensively reflects the gap between the actual effect and the expectation of the control command. However, it is a scalar or low-dimensional data and cannot be directly applied to the coordinate system of multi-dimensional state space.

[0156] Therefore, the execution deviation vector can be decomposed using a dimension mapping table. Each component of the execution deviation value corresponds to a specific dimension of the spatial coordinates; temperature deviation is mapped to the temperature coordinate axis, and energy consumption deviation is mapped to the power consumption coordinate axis. By decomposing the execution deviation value into a set of corresponding components according to the dimensions of the spatial coordinates (such as temperature, remaining battery power, signal strength, processor load rate, etc.), a dimension deviation vector is formed.

[0157] For example, if the execution deviation value shows "energy consumption exceeds budget and temperature rises", then the dimensional deviation vector will show a positive component on the "energy consumption axis" (indicating the need for correction towards lower energy consumption) and a positive component on the "temperature axis" (indicating the need to move towards a lower temperature state). By transforming the abstract deviation into a perceptible direction vector in the state space, precise navigation coordinates are provided for the physical movement of subsequent node coordinates.

[0158] Step S802: Obtain the spatial distance between the current state node and multiple neighboring nodes, and calculate the corrected weight coefficient of each neighboring node based on the spatial distance.

[0159] Among them, spatial distance is the Euclidean distance between the current state node and its neighboring nodes in the multidimensional state space, which directly reflects the similarity between the states they represent (the smaller the distance, the more similar they are).

[0160] In the embodiments of this application, the calculation of the corrected weight coefficient needs to reflect the rule of "the closer the distance, the greater the influence": for example, the formula "1 / (1+node distance)" (or a similar decay function) can be used to assign higher weights to adjacent nodes that are close to each other, while the weights of distant nodes approach zero.

[0161] It is understandable that adjacent nodes represent historical scenarios that are similar to but slightly different from the current state. Their proposed corrections to the current node should be positively correlated with their similarity to avoid interference from noise from irrelevant nodes in the correction direction.

[0162] Step S803: Based on the dimension deviation vector and the corrected weight coefficient, calculate the first coordinate offset of the current state node and the second coordinate offset of each adjacent node.

[0163] Among them, the first coordinate offset (current state node) is directly driven by the dimension deviation vector. That is, each component of the deviation vector is the direction and magnitude of the node's movement on each coordinate axis (e.g., if the temperature deviation is +0.1, the node moves 0.1 units in the positive direction of the temperature axis), which reflects the core requirement that the current node needs to be corrected in the opposite direction of the deviation in order to approach the ideal state.

[0164] The second coordinate offset (adjacent node) needs to be superimposed with the correction weight coefficient, that is, "the second coordinate offset of the adjacent node = deviation vector × correction weight coefficient × adjacency attenuation factor". The adjacency attenuation factor is used to control the correction attenuation of the adjacent node as the distance increases, so that the movement of the adjacent node decreases as the distance between it and the current node increases.

[0165] Understandably, the current state node is the "core object" of the correction and needs to directly respond to deviations; adjacent nodes are cooperative correctors, and their movement amount needs to take into account the correlation strength between themselves and the current node to avoid excessive local adjustments that would disrupt the overall topology of the state space.

[0166] Step S804: The first coordinate offset and the second coordinate offset are superimposed on the original spatial position coordinates of the current state node and multiple adjacent nodes, respectively, to generate the updated target spatial position coordinates.

[0167] The original spatial coordinates are the historical positioning of the node in the multidimensional state space (such as the coordinates of the cluster center or newly created node). After the offset is superimposed, the node position will move in a direction that is "closer to the actual effective state".

[0168] For example, if the current node needs to be corrected towards "low energy consumption and low temperature" due to execution deviation, its coordinates will move in the negative direction of the energy axis and the temperature axis, and the new position will be closer to the real and efficient state region. The synchronous movement of adjacent nodes follows the principle of spatial distance proportionality, ensuring that the aggregation relationship of the node group is not broken due to single-point correction, and maintaining the state space's ability to represent complex environments.

[0169] Step S805: Based on the updated target spatial location coordinates, recalculate the node adjacency relationship between the current state node and multiple neighboring nodes;

[0170] The adjacency relationship is defined by "spatial distance < preset neighborhood radius". After the node coordinates are updated, the original adjacent nodes may no longer be adjacent due to changes in distance (such as a neighboring node moving and the distance exceeding the radius), or new neighboring nodes (originally slightly exceeding the radius, now moving into the radius) need to be connected.

[0171] In this embodiment, recalculation involves measuring all node pairs using Euclidean distance, filtering node pairs that satisfy the neighborhood radius based on the new coordinates, and generating bidirectional connecting edges. By dynamically updating the topology of the state space as the node positions evolve, the error of experience migration caused by "old adjacency relationships corresponding to new positions" is avoided. For example, nodes that should be similar may be excluded from the reference range because their adjacency relationships have not been updated.

[0172] Step S806: Adjust the basic hardware control parameter set bound to the current state node according to the execution deviation value, and output the updated basic hardware control parameter set.

[0173] Among them, the basic hardware control parameter set is the historical experience consensus of the nodes (such as the average hardware parameters within a cluster), and the execution deviation value reflects the inadequacy of the original parameter set under specific conditions (such as the energy saving effect not meeting expectations or the state deviation being too large).

[0174] In this embodiment, a moving average algorithm can be used (e.g., "updated parameter = original parameter × (1 - smoothing coefficient) + target parameter × smoothing coefficient"), where the target parameter is derived from the execution deviation value (e.g., if energy consumption exceeds the limit, the target parameter will be reduced in frequency). This step optimizes the old parameters with new experience (target parameter) and avoids parameter jumps (e.g., sudden and large frequency adjustments leading to equipment instability) through the smoothing coefficient, balancing the parameter set between evolution and stability, and providing a more accurate benchmark for subsequent matching of similar states.

[0175] In the above implementation, the dimensional deviation vector generated by mapping the execution deviation value is used for navigation. Adjacent node correction weights are allocated according to spatial distance, and the coordinate offset between the current node and adjacent nodes is calculated. Node positions are updated by superposition, and adjacency relationships are reconstructed. Finally, the basic hardware control parameter set is adjusted using a moving average. This technical solution enables the multi-dimensional state space to dynamically approximate the real effective state as the device operates, solving the shortcomings of traditional static state space's empirical lag and structural rigidity. It improves the long-term adaptability, parameter matching accuracy, and system operational stability of IoT devices' adaptive dynamic power consumption adjustment.

[0176] Reference Figure 9 As a further implementation of the adaptive dynamic power consumption adjustment method, after step S104, which calculates the parameter offset trend vector for the current state node based on the state transition path, the method further includes:

[0177] Step S901: Perform dimensional decoupling processing on the current multidimensional state vector to generate a first sub-vector corresponding to the temperature dimension and a second sub-vector corresponding to the task load dimension, and calculate the dimensional conflict index between the first sub-vector and the second sub-vector.

[0178] In real-world IoT devices, deep physical coupling exists between their internal state variables. A sharp increase in workload is often the direct cause of soaring chip temperatures. While current multidimensional state vectors comprehensively represent the device's current state fingerprint, conventional overall state matching can easily mask the intensification of contradictions between specific dimensions when facing complex conflict scenarios such as high temperatures accompanied by high loads.

[0179] In this embodiment, the dimensional decoupling process makes the coupling relationship explicit by separately extracting the first sub-vector of the temperature dimension and the second sub-vector of the task load dimension from the current multidimensional state vector. Specifically, taking the current multidimensional state vector as [0.9, 0.8, 0.1, ...] as an example, firstly, dimensional decoupling is performed using a preset dimensional index to extract the first sub-vector value of the corresponding temperature dimension as 0.9 and the second sub-vector value of the corresponding task load dimension as 0.1; then, based on the positive correlation coupling constraint relationship between temperature and task load implied by the historical cluster nodes in the multidimensional state space, a pre-fitted load expectation mapping function is called to calculate that the expected task load value corresponding to a temperature of 0.9 should be 0.8; finally, the absolute difference between the actual extracted second sub-vector value and the expected task load value is calculated, i.e., the dimensional conflict index = |0.1-0.8| = 0.7. This specific difference value accurately quantifies the degree of contradiction of the current "high temperature but low load" which seriously deviates from the historical normal coupling pattern.

[0180] Step S902: When the dimension conflict index is greater than or equal to the preset conflict threshold, a dynamic suppression coefficient corresponding to the dimension conflict index is generated based on the preset conflict mapping relationship table, and the magnitude of the parameter offset trend vector is attenuated based on the dynamic suppression coefficient to generate the suppressed parameter offset trend vector.

[0181] The parameter offset trend vector is a dynamic guide calculated based on the state transition paths of adjacent nodes in a stable historical period. Its implicit premise is that the device state changes gradually within normal constraints. However, when the dimensional conflict index indicates that the device has fallen into a serious physical coupling conflict (such as the coexistence of high temperature and high load), continuing to use the conventional trend (such as continuing to increase the frequency to improve the response speed according to historical habits) is very likely to trigger overheat protection or permanent damage.

[0182] In this embodiment, a pre-defined conflict mapping table stores the correspondence between conflict intensity and security suppression strength (e.g., a conflict index of 0.8 corresponds to a suppression coefficient of 0.5, and a conflict index of 0.9 corresponds to 0.2). Essentially, this empirically quantifies the security strategy of "the greater the conflict, the smaller the adjustment range should be." The dynamic suppression coefficient is generated based on this and applied to the amplitude of the trend vector. This attenuation process is not a simple truncation, but rather a proportional reduction in adjustment actions that might exacerbate the conflict (e.g., reducing the CPU frequency increase trend from +0.3GHz to +0.06GHz) according to the conflict intensity, ensuring that subsequent control commands operate within the safety boundary and achieving a dynamic balance of "safety first, aggressive optimization second."

[0183] It should be noted that when the dimension conflict index is less than the preset conflict threshold, the parameter offset trend vector is directly used as the final parameter offset trend vector, and no further steps are required.

[0184] Step S903: Based on the preset boundary distance threshold, filter the state nodes in the multidimensional state space, determine multiple edge state nodes located at the spatial distribution boundary, and extract the edge hardware control parameter set bound to each edge state node.

[0185] Among them, the nodes located at the geometric center of the multidimensional state space represent common stable operating conditions, while the edge state nodes located at the boundary of the spatial distribution represent extreme or rare operating conditions that the equipment has encountered in the past (such as the edge of power depletion, the critical point of temperature threshold).

[0186] In this embodiment, a preset boundary distance threshold (such as the farthest distance from the center of space) is used to accurately delineate these edge state nodes. By extracting the set of edge hardware control parameters bound to these edge nodes, such as the parameter "CPU downclocked to 1.0GHz + non-core peripherals disabled" used by an edge node to successfully maintain operation at 95°C, we are essentially obtaining survival strategies that have been verified by the device in past extreme crises. Although these strategies are not applicable to daily life, they are the most valuable emergency response plan reserves when current conflicts escalate.

[0187] Step S904: Calculate the difference between each edge hardware control parameter set and the basic hardware control parameter set bound to the current state node, and generate multiple parameter difference quantities.

[0188] The set of basic hardware control parameters bound to the current state node represents the baseline strategy for dealing with similar normal operating conditions (e.g., "CPU 2.0GHz + communication power 5dBm"), while the set of edge hardware control parameters represents the special intervention strategy for dealing with extreme operating conditions (e.g., "CPU 1.0GHz + communication power 2dBm"). By directly calculating the numerical parameter differences between the two (e.g., CPU frequency difference -1.0GHz, communication power difference -3dBm), the absolute numerical appearance of the parameters is stripped away in a physical sense, and the core adjustment components that can correct the current conflict state are accurately extracted.

[0189] Step S905: Calculate the weighted sum of parameter differences based on the difference weight coefficients to generate a global difference compensation vector; wherein, the difference weight coefficients are calculated based on the spatial distance between multiple edge state nodes and the current state node;

[0190] The difference weight coefficient is set according to the principle of "the higher the similarity, the greater the reference value", and is calculated by the spatial distance between the edge state node and the current state node (the closer the distance, the greater the weight). This is because although different edge nodes in multidimensional space are all at the boundary, some are biased towards the low power limit and some are biased towards the pure high temperature limit.

[0191] In this embodiment, multiple parameter differences are fused by spatial distance weighting. The resulting global difference compensation vector is no longer a replication of a single historical extreme case, but rather a synthesis of the collective wisdom of various boundary constraints in a multi-dimensional space. For example, if the current conflict state is spatially closest to a certain "high temperature + high load" edge node, then the parameter difference of that node will be given the highest weight, dominating the direction of the compensation vector, while the experience of other edge nodes will serve as auxiliary corrections.

[0192] Step S906: The global difference compensation vector is superimposed on the suppressed parameter offset trend vector to generate a compensated parameter offset trend vector for subsequent fusion processing with the basic hardware control parameter set.

[0193] Among them, the suppressed parameter offset trend vector has eliminated dangerous components and retained the safety feature of fine-tuning along the historical stable path; while the global difference compensation vector carries the powerful correction energy to forcibly pull the equipment back to the safe area from the conflict.

[0194] By superimposing the two, a perfect integration of conventional dynamic prediction and extreme boundary intervention is achieved. This results in a final compensated parameter offset trend vector that retains the dynamic continuity of smooth adjustments along historical state transition paths while also embedding a compensating torque that forcibly pulls the device state back from the conflict zone to a safe area. When this vector is subsequently integrated with the basic hardware control parameter set, it can directly produce a target hardware control instruction set that avoids excessive oscillations while accurately addressing the pain points of multi-factor coupling.

[0195] In the above implementation, a dynamic balance mechanism is constructed between historical trend prediction and real-time extreme conflicts. By decoupling dimensions, it accurately identifies multi-variable coupling conflicts and intelligently suppresses the blindness of conventional trends. At the same time, it deeply mines the extreme survival experience of edge nodes in the multi-dimensional state space and makes weighted references based on spatial distance. Finally, it deeply integrates safety constraints and boundary compensation into the parameter adjustment vector, which effectively overcomes the defects of traditional solutions in the face of complex conflict scenarios, such as drastic parameter adjustment jumps and easy getting trapped in local suboptimal solutions. It improves the accuracy, robustness and long-term adaptive evolution capability of power consumption adjustment of IoT devices under extreme conditions of multi-factor dynamic coupling.

[0196] This application also discloses an adaptive dynamic power consumption adjustment system for Internet of Things (IoT) devices.

[0197] An adaptive dynamic power consumption regulation system for Internet of Things (IoT) devices specifically includes:

[0198] The state perception and encoding module is used to acquire real-time environmental parameters and device operating parameters of IoT devices and encode them to generate the current multi-dimensional state vector.

[0199] The node matching and parameter extraction module is used to input the current multidimensional state vector into a pre-constructed multidimensional state space for node matching, determine the current state node, and extract the set of basic hardware control parameters bound to the current state node. The multidimensional state space consists of multiple state nodes formed by clustering historical state vectors, and the spatial distribution of each state node represents the coupling constraint relationship between power, temperature, network quality and task load.

[0200] The adjacency node acquisition module is used to acquire multiple adjacency nodes of the current state node in the multidimensional state space;

[0201] The trend prediction calculation module is used to extract the state transition paths of multiple neighboring nodes within a historical time period, and calculate the parameter offset trend vector for the current state node based on the state transition paths.

[0202] The instruction fusion generation module is used to fuse the basic hardware control parameter set with the parameter offset trend vector to generate the target hardware control instruction set, and then send it to the hardware driver layer for adjustment.

[0203] The execution deviation calculation module is used to collect actual energy consumption data and actual state parameters after hardware adjustment, and calculate the execution deviation value for the current state node.

[0204] The parameter self-evolution module is used to offset and correct the spatial position coordinates of the current state node and its adjacent nodes in the multi-dimensional state space according to the execution deviation value, and update the bound basic hardware control parameter set.

[0205] An adaptive dynamic power consumption adjustment system for IoT devices according to an embodiment of this application can implement any of the above methods, and the specific working process of each module in the system can refer to the corresponding process in the above method embodiments.

[0206] In the several embodiments provided in this application, it should be understood that the provided methods and systems can be implemented in other ways. For example, the system embodiments described above are merely illustrative; for example, the division of a certain module is merely a logical functional division, and in actual implementation there may be other division methods, such as multiple modules can be combined or integrated into another system, or some features can be ignored or not executed.

[0207] The above are all preferred embodiments of this application and are not intended to limit the scope of protection of this application. Any feature disclosed in this specification (including the abstract and drawings) may be replaced by other equivalent or similar features unless specifically stated otherwise. That is, unless specifically stated otherwise, each feature is only one example of a series of equivalent or similar features.

Claims

1. An adaptive dynamic power consumption adjustment method for Internet of Things (IoT) devices, characterized in that, The method includes: Acquire real-time environmental parameters and device operating parameters of IoT devices and encode them to generate a current multi-dimensional state vector; The current multidimensional state vector is input into a pre-constructed multidimensional state space for node matching to determine the current state node and extract the set of basic hardware control parameters bound to the current state node; wherein, the multidimensional state space is composed of multiple state nodes formed by clustering historical state vectors, and the spatial location distribution of each state node represents the coupling constraint relationship between power, temperature, network quality and task load. Obtain multiple adjacent nodes of the current state node in the multidimensional state space; Extract the state transition paths of the multiple neighboring nodes within a historical time period, and calculate the parameter offset trend vector for the current state node based on the state transition paths; The basic hardware control parameter set and the parameter offset trend vector are fused together to generate the target hardware control instruction set, which is then sent to the hardware driver layer for adjustment. Collect actual energy consumption data and actual state parameters after hardware adjustment, and calculate the execution deviation value for the current state node; The spatial position coordinates of the current state node and its adjacent nodes in the multidimensional state space are offset and corrected according to the execution deviation value, and the bound basic hardware control parameter set is updated.

2. The adaptive dynamic power consumption adjustment method for IoT devices according to claim 1, characterized in that, The steps for acquiring and encoding real-time environmental and operational parameters of IoT devices to generate the current multidimensional state vector include: The IoT device uses a built-in sensor array to collect physical environment parameters and device operating parameters in real time. The real-time environmental parameters include temperature data, acceleration data, and signal strength data, while the device operating parameters include remaining battery power data, processor load rate data, and packet loss rate data. Based on a preset dimension ratio, the temperature data, signal strength data, and remaining battery power data are standardized to generate a normalized parameter set. The acceleration data is subjected to abrupt event detection to generate a task urgency indicator; The processor load rate data and packet loss rate data are subjected to interval mapping processing to output a discretized set of operating parameters; The normalized parameter set, task urgency identifier, and discretized operation parameter set are concatenated according to a preset dimensional order to output the current multidimensional state vector.

3. The adaptive dynamic power consumption adjustment method for IoT devices according to claim 1, characterized in that, The steps for constructing the multidimensional state space include: Obtain multiple historical multidimensional state vectors and corresponding historical hardware control parameters of IoT devices within their historical operating cycles; The multiple historical multidimensional state vectors are spatially partitioned using a clustering algorithm to generate multiple cluster centers, and each cluster center is used as a state node. The average value of historical hardware control parameters belonging to the same state node is calculated, and the average value set is output as the basic hardware control parameter set bound to the state node. Calculate the spatial distance between different state nodes, and establish a bidirectional connection between state nodes whose spatial distance is less than a preset neighborhood radius to establish an adjacency relationship between the state nodes.

4. The adaptive dynamic power consumption adjustment method for IoT devices according to claim 3, characterized in that, The steps of inputting the current multidimensional state vector into a pre-constructed multidimensional state space for node matching, determining the current state node, and extracting the set of basic hardware control parameters bound to the current state node include: Calculate the spatial Euclidean distance between the current multidimensional state vector and each state node in the multidimensional state space; Determine whether the smallest spatial Euclidean distance among multiple spatial Euclidean distances is greater than a preset abnormal distance threshold; If so, then based on the spatial coordinates of the current multidimensional state vector, a new state node is generated in the multidimensional state space as the current state node, and the historical state node determined by the pre-cached historical control cycle is read, and the historical basic hardware control parameter set bound to the historical state node is configured as the basic hardware control parameter set bound to the current state node. If not, the state node corresponding to the minimum spatial Euclidean distance is taken as the current state node, and the set of basic hardware control parameters bound to the current state node is extracted.

5. The adaptive dynamic power consumption adjustment method for IoT devices according to claim 1, characterized in that, The steps of extracting the state transition paths of the multiple neighboring nodes within a historical time period and calculating the parameter offset trend vector for the current state node based on the state transition paths include: Extract the historical state vector sequence of the multiple neighboring nodes within multiple consecutive time windows before the current time from the historical log database; The historical state vector sequence is arranged in chronological order to generate state transition paths for the multiple neighboring nodes within a historical time period. The difference between the historical state vectors of adjacent time windows in the state transition path is calculated to generate multiple state difference vectors. Obtain preset time decay weight configuration parameters, perform time decay weighting processing on the state difference vector, and generate a weighted difference vector set; wherein, in the time decay weight configuration parameters, the weight corresponding to the time window that is closer to the current time is greater; The weighted difference vector set is superimposed to generate the parameter offset trend vector.

6. The adaptive dynamic power consumption adjustment method for Internet of Things (IoT) devices according to claim 5, characterized in that, After the step of calculating the parameter offset trend vector for the current state node based on the state transition path, the method further includes: The current multidimensional state vector is decoupled by dimension to generate a first sub-vector corresponding to the temperature dimension and a second sub-vector corresponding to the task load dimension, and the dimension conflict index between the first sub-vector and the second sub-vector is calculated. When the dimensional conflict index is greater than or equal to the preset conflict threshold, a dynamic suppression coefficient corresponding to the dimensional conflict index is generated based on the preset conflict mapping relationship table, and the magnitude of the parameter offset trend vector is attenuated based on the dynamic suppression coefficient to generate a suppressed parameter offset trend vector. Based on a preset boundary distance threshold, state nodes in the multidimensional state space are filtered, multiple edge state nodes located at the spatial distribution boundary are determined, and the set of edge hardware control parameters bound to each edge state node is extracted. Calculate the difference between each of the edge hardware control parameter sets and the basic hardware control parameter set bound to the current state node, and generate multiple parameter difference values; The weighted summation of the differences in the multiple parameters is calculated based on the difference weight coefficient to generate a global difference compensation vector; wherein, the difference weight coefficient is calculated based on the spatial distance between the multiple edge state nodes and the current state node; The global difference compensation vector is superimposed on the suppressed parameter offset trend vector to generate a compensated parameter offset trend vector, which is then used for subsequent fusion processing with the basic hardware control parameter set.

7. The adaptive dynamic power consumption adjustment method for Internet of Things (IoT) devices according to claim 5 or 6, characterized in that, The step of fusing the basic hardware control parameter set with the parameter offset trend vector to generate the target hardware control instruction set includes: The components of each dimension of the parameter offset trend vector are superimposed onto the corresponding parameter values ​​of the basic hardware control parameter set to generate a superimposed parameter set. Physical boundary constraints are applied to the superimposed parameter set to remove values ​​that exceed the hardware's operating range, and the parameter set after amplitude limiting is output. The parameter set after the limiting process is converted into a hardware-executable instruction format to generate the target hardware control instruction set.

8. The adaptive dynamic power consumption adjustment method for Internet of Things (IoT) devices according to claim 1, characterized in that, The steps of collecting actual energy consumption data and actual state parameters after hardware adjustments, and calculating the execution deviation value for the current state node, include: The actual energy consumption data and actual status parameters after hardware adjustments are collected through the sensor array built into the IoT device. Extract the corresponding target energy consumption data from the target hardware control instruction set, and calculate the energy consumption error value based on the actual energy consumption data and the target energy consumption data; The actual state parameters are encoded to generate a feedback multidimensional state vector, and the state deviation distance between the feedback multidimensional state vector and the current multidimensional state vector is calculated. Obtain preset weight configuration parameters, and weight and fuse the energy consumption error value and the state deviation distance to generate the execution deviation value.

9. The adaptive dynamic power consumption adjustment method for Internet of Things (IoT) devices according to claim 8, characterized in that, The steps of offsetting and correcting the spatial position coordinates of the current state node and its adjacent nodes in the multidimensional state space based on the execution deviation value, and updating the bound basic hardware control parameter set, include: The execution deviation value is mapped to the spatial coordinate dimension of the multidimensional state space to generate a dimension deviation vector; Obtain the spatial distance between the current state node and the multiple adjacent nodes, and calculate the correction weight coefficient of each adjacent node based on the spatial distance; Based on the dimensional deviation vector and the corrected weight coefficient, the first coordinate offset of the current state node and the second coordinate offset of each adjacent node are calculated respectively. The first coordinate offset and the second coordinate offset are respectively superimposed on the original spatial position coordinates of the current state node and the multiple adjacent nodes to generate the updated target spatial position coordinates; Based on the updated target spatial coordinates, the adjacency relationships between the current state node and the multiple neighboring nodes are recalculated; The set of basic hardware control parameters bound to the current state node is numerically adjusted based on the execution deviation value, and the updated set of basic hardware control parameters is output.

10. An adaptive dynamic power consumption adjustment system for Internet of Things (IoT) devices, characterized in that, The system includes: The state perception and encoding module is used to acquire real-time environmental parameters and device operating parameters of IoT devices and encode them to generate the current multi-dimensional state vector. The node matching and parameter extraction module is used to input the current multidimensional state vector into a pre-constructed multidimensional state space for node matching, determine the current state node, and extract the set of basic hardware control parameters bound to the current state node; wherein, the multidimensional state space is composed of multiple state nodes formed by clustering historical state vectors, and the spatial location distribution of each state node represents the coupling constraint relationship between power, temperature, network quality and task load. The adjacency node acquisition module is used to acquire multiple adjacency nodes of the current state node in the multidimensional state space; The trend prediction calculation module is used to extract the state transition paths of the multiple neighboring nodes within a historical time period, and calculate the parameter offset trend vector for the current state node based on the state transition paths. The instruction fusion generation module is used to fuse the basic hardware control parameter set with the parameter offset trend vector to generate a target hardware control instruction set, and send it to the hardware driver layer for adjustment. The execution deviation calculation module is used to collect the actual energy consumption data and actual state parameters after hardware adjustment, and calculate the execution deviation value for the current state node. The parameter self-evolution module is used to offset and correct the spatial position coordinates of the current state node and adjacent nodes in the multi-dimensional state space according to the execution deviation value, and update the bound basic hardware control parameter set.

Images