Vehicle control instruction generation method, electronic equipment and vehicle

Abstract

According to the vehicle control instruction generation method, the electronic device and the vehicle, load balancing is achieved through a chaos algorithm, the request pressure of a single key is dispersed to a plurality of keys, and the rate limitation of a single point (single key) is fundamentally avoided. A dynamic key scheduling method based on the chaos hopping principle and a structured cue word project are used, and personalized generation and high concurrency capability are achieved. According to the structured cue word, the natural language request of the user is converted into the structured cue word through the pre-designed rich elements, so that the change from a'fixed rule 'to a'dynamic intelligence' is realized. The high concurrency capability is guaranteed by a'dynamic key scheduling method ', and the multi-key scheduling guarantee system can process personalized generation requests of a large number of users at the same time, so that the'personalized' service becomes feasible and stable in a large-scale user scene.

Description

Technical Field

[0001] This application relates to the field of intelligent command generation technology, and in particular to a method for generating vehicle control commands, an electronic device, and a vehicle. Background Technology

[0002] During the human-machine interaction between the vehicle and the user, the vehicle generates corresponding control commands based on the user's voice or text input. However, user requests generally do not have a standard control command structure, resulting in non-standard control command generation, ineffective or erroneous control, and a poor user experience. Summary of the Invention

[0003] In view of this, the purpose of this application is to provide a method for generating vehicle control commands, an electronic device, and a vehicle, for generating control commands that conform to vehicle control command specifications stably and accurately according to user requests.

[0004] To achieve the above objectives, this application provides a method for generating vehicle control commands, comprising: In response to receiving a user request, the system determines the current index corresponding to the user request and performs dynamic key scheduling based on the current index and a random step size to obtain an available key. The user request is processed using structured engineering based on prohibited technical features and necessary technical elements to obtain structured prompt words; Control instructions are generated based on the structured prompts and the available keys.

[0005] Optionally, the step of performing dynamic key scheduling based on the current index and random step size to obtain the available key includes: The total number of keys is determined based on the list of available keys and security constraints; Generate dynamic random step size; A new index is obtained by performing random enhancement calculations based on the dynamic random step size, the total number of keys, and the current index; The available keys are obtained by filtering the keys according to the new index and the list of available keys.

[0006] Optionally, the step of performing random enhancement calculations based on the dynamic random step size, the total number of keys, and the current index to obtain a new index includes: The first jump value is determined based on the dynamic random step size and the large prime number; The second jump value is determined based on the current index and the first jump value; The new index is obtained by performing a modulo operation based on the total number of keys and the second jump value.

[0007] Optionally, the step of filtering keys based on the new index and the list of available keys to obtain the available keys includes: The target key is determined from the list of available keys based on the new index; Perform a key health check on the target key and obtain the check result; In response to the check result indicating that the target key is in a healthy state, the application programming interface is invoked based on the target key; In response to a successful API call, the system updates the index and returns a response that uses the target key as the available key for key scheduling.

[0008] Optionally, the method for generating vehicle control commands further includes: In response to the failure of the application programming interface call, an error count is performed to obtain the number of errors; In response to the error count being less than or equal to a preset threshold, a replacement index is determined based on the new index and the total number of keys, and key filtering is performed based on the replacement index and the list of available keys until the available keys are obtained.

[0009] Optionally, the method for generating vehicle control commands further includes: In response to the check result indicating that the target key is in an abnormal state, or the number of errors exceeds a preset threshold, the target key is marked and a replacement index is determined based on the new index and the total number of keys. Then, key filtering is performed based on the replacement index and the list of available keys until the available key is obtained.

[0010] Optionally, the step of performing structured engineering processing on the user request based on prohibitive technical features and necessary technical elements to obtain structured prompt words includes: The user request is converted into natural language text, and the natural language text is standardized to obtain standard input text; The standard input text is subjected to structural constraints based on the necessary technical elements to obtain sample prompt words; The sample prompt words are standardized to obtain the structured prompt words.

[0011] Optionally, the necessary technical elements include triggering condition elements, judgment logic elements, and execution action elements; the standard input text is structurally constrained based on the necessary technical elements to obtain prompt word examples, including: The standard input text is parsed based on the trigger condition elements to obtain trigger condition features. The trigger condition features are then matched against a preset trigger condition library to obtain the trigger condition. The standard input text is parsed according to the judgment logic elements to obtain judgment logic features. The judgment logic features are then matched against a preset judgment logic library to obtain the judgment logic. The standard input text is parsed based on the execution action elements to obtain execution action features. The execution action features are then matched against a preset execution action library to obtain the execution action. The use case generation sentence is determined based on the triggering condition, the judgment logic, and the execution action. The triggering condition, the judgment logic, and the execution action are then integrated based on the determined use case generation sentence to obtain the prompt word example.

[0012] Based on the same inventive concept, this application also provides an electronic device, including a memory, a processor, and a computer program stored in the memory and executable by the processor, wherein the processor implements the method described above when executing the computer program.

[0013] Based on the same inventive concept, this application also provides a vehicle including the electronic equipment described above.

[0014] As described above, the vehicle control command generation method, electronic device, and vehicle provided in this application, upon receiving a user request, determine the current index corresponding to the user request, and perform dynamic key scheduling based on the current index and a random step size to obtain a usable key; perform structured engineering processing on the user request based on prohibited technical features and necessary technical elements to obtain structured prompt words; and generate control commands based on the structured prompt words and the usable key. Using a random step size to determine the usable key ensures that the jump distance changes dynamically each time. This nonlinear change is a core feature of chaotic systems in determining keys and can effectively resist key sequence speculation attacks. The structured prompt words obtained after structured engineering processing of the user request based on prohibited technical features and necessary technical elements provide structured constraints on the generation of control commands, ensuring that the output control commands conform to vehicle control command specifications, guaranteeing that the generation of control commands meets standards, avoiding invalid or erroneous control commands, and improving the user experience of requesting control. Attached Figure Description

[0015] To more clearly illustrate the technical solutions in this application or related technologies, the drawings used in the description of the embodiments or related technologies will be briefly introduced below. Obviously, the drawings described below are only embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0016] Figure 1 This is a flowchart of a method for generating vehicle control commands according to an embodiment of this application; Figure 2 This is a schematic diagram of the key scheduling method based on the chaotic jump principle in an embodiment of this application; Figure 3 This is a flowchart illustrating the dynamic key scheduling based on the current index and random step size in an embodiment of this application. Figure 4 This is a flowchart illustrating the determination of a new index based on randomized augmentation calculations, as described in an embodiment of this application. Figure 5 A flowchart illustrating the key screening process in this application embodiment; Figure 6 This is the intended process for applying structured constraints to standard input text in the embodiments of this application; Figure 7 This is a schematic diagram of a vehicle control command generation device according to an embodiment of this application; Figure 8 This is a schematic diagram of an electronic device according to an embodiment of this application. Detailed Implementation

[0017] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with specific embodiments and the accompanying drawings.

[0018] It should be noted that, unless otherwise defined, the technical or scientific terms used in the embodiments of this application should have the ordinary meaning understood by one of ordinary skill in the art to which this application pertains. The terms "first," "second," and similar terms used in the embodiments of this application do not indicate any order, quantity, or importance, but are merely used to distinguish different components. Terms such as "comprising" or "including" mean that the element or object preceding the word encompasses the elements or objects listed after the word and their equivalents, without excluding other elements or objects. Terms such as "connected" or "linked" are not limited to physical or mechanical connections, but can include electrical connections, whether direct or indirect. Terms such as "upper," "lower," "left," and "right" are only used to indicate relative positional relationships; when the absolute position of the described object changes, the relative positional relationship may also change accordingly.

[0019] In this article, it is important to understand that any number of elements in the accompanying figures is for illustrative purposes and not for limitation, and any naming is for distinction only and has no limiting meaning.

[0020] Based on the above background description, the following situations also exist in the related technologies: When generating control commands in related technologies, an intelligent scene control scheme generation technology combining a large language model and dynamic key management is used. The implementation process of this technology is as follows: First, the language instruction parsing layer of the large language model processes the multimodal input of user requests, generating corresponding scene scripts. The large language model parses the user's natural language requests (such as "turn on home theater mode"), generating structured scene scripts that can break down ambiguous instructions (such as "turn on romantic dinner mode") into elements such as time, equipment, actions, and conditions. Through a "generation-feedback-optimization" loop, the large language model adjusts script parameters based on real-time environmental data (such as sensor input) to achieve adaptive control. The large language model borrows the "actor framework" concept, generating a coherent sequence of actions that conforms to the scene logic according to preset rules. Multimodal inputs include text instructions (such as speech-to-text "turn on home theater on weekend nights"), environmental parameters (sensor data such as temperature, humidity, and light), user profiles (historical preferences, behavioral habits), etc. When generating a script, it is necessary to identify core actions ("acceleration"), constraints ("safety first"), and scene parameters (target vehicle speed, lane change timing). For example, the user instruction "maintain viewing mode at 22℃" is parsed into a set of control decision actions: dimming the lights, starting the projector, and controlling the air conditioner temperature. And adjust the strategy according to real-time traffic conditions (such as canceling lane changes if congestion is detected).

[0021] Then, the dynamic key management layer generates and distributes keys, randomly rotating them according to a pre-defined key pool, and automatically updating keys in case of failure, thus achieving dynamic key scheduling. During key distribution, the central controller distributes one-time keys to the devices to call the application programming interface. The one-time key expires automatically after the script is executed. Key updates are triggered by script changes, network jitter, or sensitive operations (such as door lock control), and seamless key switching is achieved using pre-stored backup keys in the key pool.

[0022] Finally, after determining the control decisions and keys, the conversion from decisions to control commands is performed based on the rule base. This includes behavioral primitive conversion: high-level decisions (such as "accelerate to overtake") output by the large language model are mapped to compliant scripts composed of low-level control signals (throttle opening, steering wheel angle) based on the rule base. Vehicle control is then performed based on these compliant scripts using a PID controller or model prediction to achieve trajectory tracking. Direct trajectory control is also included: high-level decisions output by the large language model are converted into compliant scripts in the form of trajectory point sequences based on the rule base. The vehicle controller directly executes trajectory planning based on these compliant scripts, thereby achieving trajectory tracking.

[0023] In related technologies, single application programming interface (API) calls are subject to rate limits because third-party large language model service providers have default rate limits, which can lead to service interruptions. The generation of compliant scripts relies on a fixed rule base, making it impossible to generate personalized scenario control schemes (e.g., existing in-vehicle systems require manual setting of a "low-temperature driving mode"). The generated content lacks structured constraints for vehicle control commands, resulting in common errors such as missing trigger conditions or actions, leading to control errors or ineffective control and a poor user experience.

[0024] The vehicle control command generation method, electronic device, and vehicle provided in this application, upon receiving a user request, determine the current index corresponding to the user request, and perform dynamic key scheduling based on the current index and a random step size to obtain an available key; perform structured engineering processing on the user request based on prohibited technical features and necessary technical elements to obtain structured prompt words; and generate control commands based on the structured prompt words and the available key. Using a random step size to determine the available key ensures that the jump distance changes dynamically with each transition. This nonlinear change is a core feature of key determination in chaotic systems and can effectively resist key sequence speculation attacks. The structured prompt words obtained after structured engineering processing of the user request based on prohibited technical features and necessary technical elements provide structured constraints on the generation of control commands, ensuring that the output control commands conform to vehicle control command specifications, guaranteeing that the generated control commands meet standards, avoiding invalid or erroneous control commands, and improving the user experience of requesting control.

[0025] The method for generating vehicle control commands provided by the embodiments of this application will be described in detail below with reference to the accompanying drawings.

[0026] In some embodiments, such as Figure 1 As shown, the method for generating vehicle control commands includes: Step 101: In response to receiving a user request, determine the current index corresponding to the user request, and perform dynamic key scheduling based on the current index and random step size to obtain an available key.

[0027] In practice, after receiving a user request, the available key is determined by a key scheduling method based on the principle of chaotic transition (also known as the dynamic chaotic key scheduling method). Load balancing is achieved through chaotic algorithms, distributing the request pressure of a single key to multiple keys, thus fundamentally avoiding the rate limitation of a single point (single key).

[0028] The implementation process of the key scheduling method based on the chaotic jump principle is as follows: Figure 2 As shown, a portion of the algorithm description for the dynamic chaotic key scheduling method is as follows: def dynamic_key_scheduling(current_index: int, key_pool: list) ->str: Dynamic Key Scheduling Method Based on Chaotic Jump Principle parameter: current_index: Current index key_pool: List of available keys (length N≥20) return: Selected key string """ import secrets PRIME = 1013# Large prime numbers to enhance randomness step = secrets.randbelow(10) + 1 # Cryptographically secure random step size [1, 10] new_index = (current_index + step × PRIME) % len(key_pool) # Calculate the new index based on the current key index, the random step size, and the total number of keys. # Health check mechanism while not key_pool[new_index].is_healthy(): # Health check result is abnormal (unhealthy) new_index = (new_index + 1) % len(key_pool) # Recalculate the new index as the replacement index return key_pool[new_index] # Determine the available keys based on the replacement index.

[0029] Upon receiving a user request, the system first needs to determine the input parameters of the key scheduling method based on the chaotic transition principle. For the current index, each key in the key pool corresponds to one index. After determining the user request, the system allocates the corresponding current index to the user request from the index pool composed of the indices of available keys in the key pool, using either random round-robin or sequential queue selection. For the list of available keys, the key pool needs to be designed with redundancy, requiring the number of available keys (the length of the available key list) len(key_pool) ≥ 20 to ensure a sufficient number of backup keys. When a key reaches the rate limit set by the Application Programming Interface (API) provider (e.g., 100 times per minute) due to excessive calls, the system can immediately switch to another key to continue service. This avoids triggering rate limiting (e.g., HTTP 429 errors) due to frequent calls to a single key, ensuring the continuity of API service.

[0030] After determining the current index, dynamic key scheduling is performed based on the current index and the random step size to obtain the usable key, as shown in the following example: In some embodiments, such as Figure 3 As shown, dynamic key scheduling is performed based on the current index and random step size to obtain the available keys, including: Step 301: Determine the total number of keys based on the list of available keys and security constraints.

[0031] In practice, `len(key_pool)` is used to limit the key pool, representing the minimum capacity constraint. `len()` is a built-in Python function that returns the number of elements in a container object. `key_pool` is a list (or other iterable container) that stores available key strings. Therefore, `len(key_pool)` represents the number of currently available keys in the key pool. "≥ 20" is a security constraint that requires the key pool to contain at least 20 keys (i.e., `len(key_pool)` returns ≥ 20).

[0032] This security constraint is designed to ensure the security and reliability of key scheduling: it increases the entropy space because a larger key pool makes it more difficult for attackers to brute-force or predict keys. It also prevents key exhaustion: in subsequent health checks, some keys may be skipped due to expiration or being marked as unhealthy. A sufficient number of keys prevents scheduling failures due to insufficient healthy keys. This security constraint also supports chaotic transitions: the algorithm achieves non-linear transitions through prime multiplication step × PRIME, and a large key pool ensures a more uniform index distribution after the transition, reducing the risk of collisions.

[0033] Among them, safety constraints have the following beneficial effects in practical applications: Constrain the key pool initialization process to ensure that at least 20 valid keys are pre-generated when the system starts up (e.g., through random generation or key derivation).

[0034] It facilitates the dynamic maintenance of the key pool. If len(key_pool) < 20 due to key elimination (such as expiration or leakage), the key pool expansion mechanism (such as automatically generating new keys) needs to be triggered.

[0035] A security threshold is set to trigger the key pool expansion mechanism. 20 is the minimum security threshold under the security constraints on the key pool. In real-world scenarios, high-security systems may require larger capacities (e.g., len(key_pool) ≥ 100), meaning 20 can be manually set according to the actual situation.

[0036] Security is enhanced by combining encryption algorithms. For example, AES-256 requires a single key length of 256 bits (32 bytes), while len(key_pool) constrains the number of keys rather than their length. Together, they form a multi-layered security protection system.

[0037] The security constraint len(key_pool) ≥ 20, which mandates that the key pool must maintain at least 20 available keys, can be summarized as follows: improving the system's resistance to brute-force attacks; ensuring the effectiveness of chaotic jump scheduling; and providing redundancy for the key expiration mechanism.

[0038] Under security constraints, the total number of keys must be greater than or equal to 20. When the total number of keys is less than 20, the expansion mechanism of the available key list is triggered, and new keys are automatically generated so that the total number of keys is restored to a state greater than or equal to 20.

[0039] Step 302: Generate a dynamic random step size.

[0040] In practice, the random step size is used to improve the security of the key scheduling process. The scheduling algorithm uses the dynamic_key_scheduling function to generate the random step size step[1,10]. The random step size is dynamically generated by a cryptographically secure random number generator. Its role is not only in simple index offset, but also one of the core designs for the security of the entire key scheduling process.

[0041] First, the core security function of random step size is to enhance the unpredictability of key selection.

[0042] Random step size can disrupt the continuity of the index. If a fixed step size (such as step=1) is used directly, the key selection path will exhibit a linear pattern (e.g., index+1, index+2,...), and attackers can infer subsequent indices through historical key sequences. Random step size (step = secrets.randbelow(10)+1) makes the jump distance dynamically change between [1,10], and combined with the multiplicative amplification effect of the large prime number PRIME=1013, it spreads small-range random numbers to a larger space, making the index sequence chaotic and impossible to predict by simple modeling.

[0043] Random step sizes also protect against replay and traversal attacks. In long-session scenarios such as connected vehicles, fixed step sizes are vulnerable to brute-force traversal (e.g., trying all possible step values). The combination of random step sizes and dynamic indexing ensures that each key update path is unique and temporarily valid. Even if an attacker intercepts a key, they cannot reproduce or predict the next key location, significantly increasing the cost of replay attacks and protecting vehicle security.

[0044] Secondly, random step size enables adversarial attack strategies against nonlinear transformations and entropy enhancement.

[0045] Combining a random step size with a large prime number enables non-linear transformation of multiplication (step × PRIME). Multiplication of a large prime number PRIME with a random step size achieves a non-linear transformation: Prime number characteristics: PRIME and the key pool length len(key_pool) are usually coprime (the greatest common divisor is 1), ensuring that the result of (step × PRIME) % N uniformly covers the entire index space, avoiding periodic vulnerabilities caused by common factors.

[0046] Random step size can also obfuscate the effect: for example, when N=20, the distribution of the result of step×1013 % 20 has no direct linear relationship with step (such as step=1→1013%20=13, step=2→2026%20=6), increasing the difficulty of reverse engineering.

[0047] Random step sizes are also used in cryptographically secure entropy sources (secrets module). secrets.randbelow(10) generates unpredictable step sizes based on the operating system's cryptographically secure random source (such as / dev / urandom). Compared to ordinary random number generators (such as Python random), its entropy quality meets the NIST SP 800-90A standard, preventing brute-force attacks on key sequences due to weak random numbers.

[0048] Finally, random step size can improve the balance between performance and safety.

[0049] Random step sizes can optimize computational overhead. Setting a random step size range of [1, 10] balances security and performance: Low latency: `secrets.randbelow(10)` takes approximately 0.5~2μs on mainstream CPUs, far lower than dynamic key generation (e.g., ECC requires 30ms), making it suitable for high-frequency update scenarios. Avoiding overload: If the step size range is too large (e.g., [1, 1000]), the number of health check loops may increase, causing latency jitter. Smaller step sizes reduce the potential overhead of health checks.

[0050] Randomized step size facilitates fault tolerance in health checks. Since the randomized step size might point to an invalid key (e.g., a health status of False), bit-by-bit probing via `while not key_pool[new_index].is_healthy()` ensures that a valid key is output at the end. This mechanism compensates for invalid index issues that might arise from modulo operations, improving scheduling robustness.

[0051] In summary, the random step size acts as a security entropy amplifier in key scheduling. It generates a small-range perturbation through a cryptographically secure random source and diffuses it nonlinearly through prime multiplication to achieve strong unpredictability of index jumps. It effectively resists replay attacks, sequence prediction, and brute-force traversal, and is the core defense line for dynamic key updates. The small-range random number balances low latency and health check efficiency, making it suitable for scenarios such as vehicle networking and real-time communication.

[0052] Step 303: Perform random enhancement calculations based on the dynamic random step size, the total number of keys, and the current index to obtain a new index.

[0053] In practical implementation, the large prime number PRIME = 1013 is mainly used in the algorithm to enhance randomness. Prime numbers possess the mathematical properties of diffusion and non-periodicity. Prime numbers are irreducible, divisible only by 1 and themselves, and their greatest common divisor (GCD) with other numbers (especially the key pool length len(key_pool)) is usually 1. This makes the result of (step × PRIME) % len(key_pool) more evenly distributed, avoiding periodic repetitions caused by common factors in the step size and modulus. Large prime numbers also have a multiplicative amplification effect, amplifying the small range of random step sizes (1-10) to a larger numerical space (1013-10130) through step × PRIME. After modulo, it can cover all indices in the key pool, ensuring more significant randomness in jump paths.

[0054] Large prime numbers can also improve the algorithm's resilience and security. Large prime numbers can disrupt linear relationships; if (current_index + step) % N is used directly, attackers might be able to infer the step size pattern by observing the index sequence. Introducing large prime number multiplication makes the mapping between the random step size and the final index non-linear, increasing the difficulty of reverse engineering.

[0055] To enhance unpredictability, secrets.randbelow(10) generates unpredictable random step sizes based on an operating system-encrypted secure random source (such as / dev / urandom). Large prime numbers further enhance randomness, making the output index independent of the current index.

[0056] A large prime number can be 1013, which is a 4-bit prime number and is sufficiently effective when the key pool is small (e.g., N=20~100). However, for higher security (e.g., a key pool of thousands), it is recommended to upgrade to a larger prime number (e.g., 1024 bits) to resist brute-force attacks. Large prime numbers can also supplement health checks by using a loop while not key_pool[new_index].is_healthy() to ensure that even if there is an index collision, the final output is still a valid key, avoiding the accumulation of invalid results caused by modulo operations on the number of factors.

[0057] The new index is calculated using `new_index = (current_index + step × PRIME) % len(key_pool)`, where `step × PRIME` amplifies a small range of random step sizes (10¹³ to 10¹³⁰), and the result is mapped to the key pool index space using the modulo operation `%N`. For example, if the key_pool length N = 20 and `step = 3`: `(3 × 10¹³) % 20 = 3039 % 20 = 19` → directly jumps to the last index. This introduces chaotic jump characteristics; even a small change in the random step size `step` (e.g., from 2 to 3) can cause drastic fluctuations in the output index (e.g., from 6 to 19), consistent with the extreme sensitivity of chaotic systems to initial conditions. When the ergodicity depends on large prime numbers, and `PRIME` is coprime with N, the formula can cover all indices, avoiding periodic vulnerabilities (e.g., cyclic repetition caused by a fixed step size). The calculation process disrupts the linear correlation of the indices; if the new index is calculated directly using `(current_index + step) % N`, attackers can infer the step size pattern through historical sequences. Introducing large prime number multiplication results in a non-linear relationship between the index and the step size, significantly increasing the difficulty of reverse engineering. Since each jump path is unique, even if an attacker intercepts a key, they cannot predict subsequent key positions, effectively resisting replay attacks and ensuring the security of the final usable key.

[0058] Step 304: Filter the keys based on the new index and the list of available keys to obtain available keys.

[0059] In practice, the process of determining available keys based on the new index primarily employs a key health check mechanism. Key health checks refer to the systematic verification of a key's validity, security, and availability to ensure it remains in a trusted state throughout its lifecycle. Key health checks aim to dynamically monitor key status and prevent security risks caused by key expiration. This requires monitoring key validity—whether the key has expired or been revoked—as well as key security—whether it has been leaked, tampered with, or has been compromised—and key availability—whether the key materials are accessible and fully functional (e.g., successful encryption / decryption and signature verification).

[0060] During the key health check, a loop detection and bit-by-bit probing strategy is adopted. The workflow is to traverse the key pool bit by bit through a while loop. If the health status of the key corresponding to the new index new_index is False (is_healthy() returns False), the index is incremented by 1 (modulo operation to prevent out-of-bounds errors) until the first healthy key is found. The first healthy key is then determined as a usable key.

[0061] Key health checks ensure key availability and prevent the distribution of expired keys. They directly skip invalid keys caused by expiration, leakage, or associated resource failures, ensuring that scheduling results are always available. Key health checks also enable dynamic fault tolerance, automatically switching to backup keys to maintain service continuity when some keys are temporarily unavailable (e.g., a brief HSM outage).

[0062] Key health checks enable fault isolation and self-healing. Key health checks can contain localized faults; after an abnormal key is marked as unhealthy, the system can trigger asynchronous repairs (such as key regeneration or resource restart), preventing the spread of single-point faults.

[0063] Key health checks can be integrated with the operation and maintenance system. Abnormal health status can trigger alarms or self-healing tasks (such as automatically replacing invalid keys).

[0064] Key health checks can enhance system stability. They can also achieve load balancing by disabling unhealthy keys, indirectly directing traffic to available resources and preventing resource overload.

[0065] Key health checks can ensure long-term operational reliability. In long-session scenarios such as vehicle networking, health checks ensure that the key pool remains highly available over time (actual availability >99.9%).

[0066] For the algorithm as a whole, key health checks can compensate for the blind spots of random jumps. While chaotic jumps (calculation of the new index `new_index`) improve the unpredictability of the index, they cannot guarantee the validity of the selected key. Health checks, as a post-verification layer, ensure both security and availability. Key health checks guarantee the integrity of the attack resistance chain. If an attacker intentionally contaminates some keys, health checks can isolate the compromised keys, forcing the attacker to compromise more nodes simultaneously, significantly increasing the attack cost. Key health checks enhance stealth; attackers cannot deduce the key pool's failure state by observing the scheduling results (because both the jump path and health checks are dynamically changing).

[0067] The health check mechanism, through real-time bit-by-bit verification and fault key isolation, becomes an indispensable availability protection layer in the chaotic key scheduling process. Its core value lies in ensuring that the key selected by the chaotic transition is 100% available, making up for the practical blind spots of pure random algorithms, while providing security gains. Together with the transition, it builds a dual defense line of "random selection - availability verification", improving the system's ability to resist complex attacks and ensuring security.

[0068] Step 102: Perform structured engineering processing on the user request based on the prohibited technical features and necessary technical elements to obtain structured prompt words.

[0069] In some embodiments, the user request is subjected to structured engineering processing based on prohibited technical features and necessary technical elements to obtain structured prompt words, including: The user request is converted into natural language text, and the natural speech text is standardized to obtain standard input text; The standard input text is structured and constrained according to the necessary technical elements to obtain sample prompt words; The prompt word samples are standardized to obtain structured prompt words.

[0070] In practical implementation, prohibitive technical features are used to restrict the prompt words from containing serial numbers, blank lines, and descriptive information unrelated to vehicle control, ensuring the structure of the prompt words and the specificity of the vehicle control commands. Essential technical elements are the elements that the system prompt words must contain, including three core modules: triggering mechanism, judgment logic, and execution action. The triggering mechanism includes 34 preset trigger scenarios (such as time triggering, state triggering, etc.). The judgment logic includes 20 types of preset logical judgment rules (such as numerical threshold judgment, state validity judgment, etc.). The actions to be executed include 45 types of preset vehicle control operation commands (such as air conditioning adjustment, door and window control, etc.).

[0071] After converting user requests into natural language text, the natural language text is structurally constrained using prohibitive technical features and necessary technical elements to generate valid prompt words with different triggering mechanisms, judgment logic, and execution actions. To ensure the standardization of the structural prompt words, the input natural language text and the output prompt word samples are standardized. The original input text is split into multiple lines of strings according to newline characters, and all blank lines and lines containing only whitespace characters are filtered out, retaining valid content lines and forming an ordered list. The standardization process is as follows: content_list = [line for line in content.split("\n") if line.strip()] Here, `content` is the original input text (input natural language text or output prompt word sample), `content_list` is the list of valid content after standardization (standard input text or structure prompt words), and `line.strip()` is used to determine whether the line content is non-whitespace characters.

[0072] During the standardization process, the original input text is split using `content.split("\n")`, which divides the original input text `content` into a list of strings based on the newline character `\n`, with each element representing a line of text. `split("\n")` strictly uses `\n` as the delimiter. If the text contains Windows newline characters (`\r\n`), additional processing is required (e.g., using `splitlines()` for automatic compatibility).

[0073] You can use `if line.strip()` to filter blank lines. `line.strip()` removes leading and trailing whitespace characters (including spaces, tabs `\t`, newlines `\n`, etc.) from the current line and returns the processed string. If the string after `strip()` is empty (""), it means the line has no valid content and is filtered; otherwise, it is retained.

[0074] Finally, a new list is dynamically constructed using `[line for line in ... if ...]`, containing only lines that meet the conditions while maintaining the original line order. For example, if the original input text is "\t", it is not retained. If the original input text is "Hello", `line.strip()` returns "Hello". If the original input text is "text\n", `line.strip()` returns "text".

[0075] After standardizing the sample prompts, we obtain structural prompts that meet the requirements and conform to the vehicle control command specifications.

[0076] Step 103: Generate control instructions based on structured prompts and available keys.

[0077] In practice, the first step is to deconstruct the structured prompts, parsing the user-inputted structured prompts into control elements that the controller can execute (e.g., trigger mechanism + judgment logic + execution action + control priority) according to a preset template. Then, based on the available key's permission verification, the scope of the available key's permissions is verified: if the key's permissions include the control permissions corresponding to the structured prompts, verification passes; if the permissions do not include the control permissions corresponding to the structured prompts, a rejection response is triggered.

[0078] For example, after determining that the corresponding permissions are available, the judgment conditions are dynamically constructed based on the triggering mechanism, judgment logic and vehicle sensor data (such as in-vehicle temperature and humidity) in the control element. Combined with environmental data and user preferences (such as historical settings), the control parameters are dynamically adjusted to generate the initial control command corresponding to the action to be executed in the control element. The initial control command is then marked with the corresponding control priority to obtain the final control command and complete the generation of the effective control command.

[0079] In summary, the vehicle control command generation method provided in this application achieves load balancing through chaotic algorithms, distributing the request pressure of a single key across multiple keys, fundamentally avoiding the rate limitation of a single point (single key). It uses a dynamic key scheduling method based on the chaotic jump principle combined with structured prompt word engineering to collaboratively and indirectly achieve "personalized generation" and "high concurrency capability." Personalized generation is mainly solved by "structured prompt word engineering." Structured prompt words transform the user's natural language request (e.g., "I'm so hot") into structured prompt words through pre-designed elements containing rich elements (34 trigger scenarios, 20 judgment rules, and 45 execution actions). Based on the available keys and structured prompts, it generates personalized control commands conforming to automotive standards (e.g., "If the interior temperature is >28℃ and the vehicle is in motion, then adjust the air conditioning to 22℃"). This realizes a shift from "fixed rules" to "dynamic intelligence." High concurrency is ensured by a "dynamic key scheduling method based on the principle of chaotic transitions." This multi-key scheduling system guarantees that it can simultaneously handle a large number of personalized generation requests from users, making "personalized" services feasible and stable in large-scale user scenarios. It ensures that the output control commands conform to vehicle control command specifications while guaranteeing the stability of command generation, thus improving the user experience for requesting control.

[0080] In some embodiments, such as Figure 4 As shown, a new index is obtained by performing random enhancement calculations based on the dynamic random step size, the total number of keys, and the current index, including: Step 401: Determine the first jump value based on the dynamic random step size and the large prime number.

[0081] In practice, the product of the random step size and a large prime number (i.e., step × PRIME) is determined as the first jump value. The first jump value enhances randomness through the use of a large prime number; 10¹³ is chosen as the multiplier (not a simple step size). The irreducibility of prime numbers disrupts the linear pattern of index changes, making the jump trajectory exhibit chaotic characteristics. For example, when step changes, the index might suddenly jump from position 5 to (5 + 3 × 10¹³) % 20 = 4, instead of moving sequentially. The first jump value enhances sensitivity through the random step size. Small perturbations in the current index or the random step size (such as a step change of ±1) are amplified by the multiplication effect of the large prime number, causing the new index to deviate completely from the current index (e.g., the multiples of 10¹³ are not evenly distributed), consistent with the characteristic of chaotic systems being sensitive to initial conditions.

[0082] The first jump value, step × PRIME, amplifies the small range of random step sizes (10¹³ to 10¹³⁰), and then maps the result to the key pool index space using the modulo operation % N. For example, if the key_pool length N = 20 and step = 3: (3 × 10¹³) % 20 = 3039 % 20 = 19 → directly jumps to the last index. This introduces chaotic jump characteristics; even a small change in the random step size step (e.g., from 2 to 3) can cause drastic fluctuations in the output index (e.g., from 6 to 19), consistent with the extreme sensitivity of chaotic systems to initial conditions. When the ergodicity depends on large prime numbers, and PRIME is coprime with N, the formula can cover all indices, avoiding periodic vulnerabilities. Step 402: Determine the second jump value based on the current index and the first jump value.

[0083] In practice, the sum of the current index and the first jump value (current_index + step × PRIME) is determined as the second jump value. Based on the amplification effect of multiplication of large prime numbers, when the current index undergoes a tiny perturbation, the final calculated new index deviates completely from the current index (because the multiples of 1013 are not evenly distributed), which is consistent with the characteristic of chaotic systems being sensitive to initial conditions.

[0084] Step 403: Perform modulo operations based on the total number of keys and the second jump value to obtain a new index.

[0085] In practice, the new index is calculated using `new_index = (current_index + step × PRIME) % len(key_pool)`. The `% len(key_pool)` (modulo the key pool length) is the core operation that ensures the new index `new_index` remains within a valid range. Regardless of the value of the second jump, the modulo operation maps the new index to the valid range [0, len(key_pool) - 1]. The key pool is a fixed-length list of available keys. If the new index exceeds this range, the program will crash; the modulo operation eliminates this risk through mathematical mapping. The modulo operation automatically returns the new index to the beginning when it reaches the end (e.g., 19 + 1 = 20 → 20 % 20 = 0), forming a logical "circular buffer". Combined with a random step size and large prime numbers, the jump path exhibits a non-linear traversal in the circular space, preventing the prediction of fixed patterns.

[0086] In some embodiments, such as Figure 5 As shown, based on the new index and the list of available keys, the available keys are obtained through key filtering, including: Step 501: Determine the target key from the list of available keys based on the new index.

[0087] In specific implementation, such as Figure 2 As shown, the target key is obtained by searching the list of available keys based on the new index.

[0088] Step 502: Perform a key health check on the target key and obtain the check results.

[0089] In practice, the target key is subjected to a health check based on the key health check mechanism, and the check results are obtained.

[0090] Step 503: In response to the check result indicating that the target key is in a healthy state, the application programming interface is invoked based on the target key.

[0091] In practice, if the check result indicates that the target key is in a healthy state, the target key is retained, the application programming interface is called based on the target key, and it is determined whether the application programming interface can be successfully called.

[0092] Step 504: In response to a successful application programming interface call, update the index and return a response that sets the target key as the available key for key scheduling.

[0093] In practice, if the application programming interface call successfully updates the index and returns a response that uses the target key as the available key for key scheduling, it is determined that the available key has been successfully obtained, and the control instruction generation process is triggered.

[0094] In some embodiments, such as Figure 2 As shown, the available keys are obtained by filtering based on the new index and the list of available keys, and also include: In response to failed application programming interface (API) calls, an error count is performed to obtain the number of errors. In response to an error count being less than or equal to a preset threshold, a replacement index is determined based on the new index and the total number of keys. Then, keys are filtered based on the replacement index and the list of available keys until a usable key is obtained.

[0095] In practice, if the application programming interface call fails, to avoid false positives, an error count is performed, i.e., an error count confirmation process of error count = error count + 1 is initiated with an initial value of 0. When the error count is less than or equal to a preset threshold (e.g., 3 times), the target key is not directly marked as an unusable key. Instead, a new index is recalculated based on the new index and the total number of keys to determine the replacement index. Key filtering is then performed based on the replacement index and the list of available keys until a usable key is obtained.

[0096] In some embodiments, such as Figure 2 As shown, the available keys are obtained by filtering based on the new index and the list of available keys, and also include: In response to the check result indicating that the target key is in an abnormal state, or the number of errors exceeds a preset threshold, the target key is marked and a replacement index is determined based on the new index and the total number of keys. Then, the key is filtered based on the replacement index and the list of available keys until a usable key is obtained.

[0097] In practice, if the key health check results in the target key being in an abnormal state, or the number of errors exceeding a preset threshold, the target key is marked as an unusable key. A replacement index is determined based on the new index and the total number of keys (new_index = (new_index + 1) % len(key_pool)). Keys are then filtered based on the replacement index and the list of available keys until a usable key is obtained.

[0098] In some embodiments, the essential technical elements include triggering condition elements, judgment logic elements, and execution action elements; such as Figure 6 As shown, the standard input text is structurally constrained according to the necessary technical elements to obtain sample prompt words, including: Step 601: Parse the standard input text according to the trigger condition elements to obtain the trigger condition features, and match the trigger condition features in the preset trigger condition library to obtain the trigger condition; Step 602: Parse the standard input text according to the judgment logic elements to obtain the judgment logic features, and match the judgment logic features in the preset judgment logic library to obtain the judgment logic; Step 603: Parse the standard input text based on the execution action elements to obtain the execution action features, and match the execution action features with the preset execution action library to obtain the execution action; Step 604: Determine the test case generation sentence pattern based on the triggering conditions, judgment logic, and execution actions. Integrate the triggering conditions, judgment logic, and execution actions based on the determined test case generation sentence pattern to obtain the prompt word sample.

[0099] In practical implementation, the essential technical elements are the elements that the system prompt words must include, including three core modules: triggering mechanism, judgment logic, and execution action. The triggering mechanism includes 34 preset trigger scenarios (such as time triggering, state triggering, etc.). The judgment logic includes 20 types of preset logical judgment rules (such as numerical threshold judgment, state validity judgment, etc.). The actions to be executed include 45 types of preset vehicle control operation commands (such as air conditioning adjustment, door and window control, etc.).

[0100] The system then analyzes the standard input text to determine the trigger condition features, judgment logic features, and execution action features. Based on the trigger condition features, it determines the trigger condition corresponding to the current user request from 34 preset trigger scenarios; based on the judgment logic features, it determines the judgment logic corresponding to the current user request from 20 preset logic judgment rules; and based on the execution action features, it determines the execution action corresponding to the current user request from 45 preset vehicle control operation instructions.

[0101] The test case generation sentence structure is a template style generated from the prompt word examples, such as: "When...then...", "If...then...", "When I say...yes, then...". The corresponding prompt word examples could be: "When nap mode ends, turn on the headlights.", "If the vehicle speed exceeds 120, give the user a voice prompt.", "When the user says they are tired, turn on the seat massage." Then, the prompt word examples are standardized to obtain the corresponding structured prompt words.

[0102] It should be noted that the method in this embodiment can be executed by a single device, such as a computer or server. The method can also be applied in a distributed scenario, where multiple devices cooperate to complete the task. In such a distributed scenario, one of these devices may execute only one or more steps of the method in this embodiment, and the multiple devices will interact with each other to complete the method described.

[0103] It should be noted that the above description describes some embodiments of this application. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recorded in the claims can be performed in a different order than that shown in the above embodiments and still achieve the desired result. Furthermore, the processes depicted in the drawings do not necessarily require a specific or sequential order to achieve the desired result. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.

[0104] Based on the same inventive concept, corresponding to any of the above embodiments, this application also provides a vehicle control command generation device.

[0105] refer to Figure 7 The vehicle control command generation device includes: The dynamic key generation module 10 is configured to: in response to receiving a user request, determine the current index corresponding to the user request, and perform dynamic key scheduling based on the current index and a random step size to obtain a usable key; The structured prompt word module 20 is configured to: perform structured engineering processing on user requests based on prohibited technical features and necessary technical elements to obtain structured prompt words; The control instruction generation module 30 is configured to generate control instructions based on structured prompts and available keys.

[0106] Optionally, the dynamic key generation module 10 is also configured to: The total number of keys is determined based on the list of available keys and security constraints; Generate dynamic random step size; A new index is obtained by performing random enhancement calculations based on the dynamic random step size, the total number of keys, and the current index. The available keys are obtained by filtering the keys based on the new index and the list of available keys.

[0107] Optionally, the dynamic key generation module 10 is also configured to: The first jump value is determined based on the dynamic random step size and a large prime number; Determine the second jump value based on the current index and the first jump value; A new index is obtained by performing a modulo operation based on the total number of keys and the second jump value.

[0108] Optionally, the dynamic key generation module 10 is also configured to: The target key is determined from the list of available keys based on the new index; Perform a key health check on the target key and obtain the check results; In response to the check result indicating that the target key is in a healthy state, the application programming interface is invoked based on the target key; In response to a successful application programming interface call, the index is updated and the target key is returned as the available key for key scheduling.

[0109] Optionally, the dynamic key generation module 10 is also configured to: In response to failed application programming interface (API) calls, an error count is performed to obtain the number of errors. In response to an error count being less than or equal to a preset threshold, a replacement index is determined based on the new index and the total number of keys. Then, keys are filtered based on the replacement index and the list of available keys until a usable key is obtained.

[0110] Optionally, the dynamic key generation module 10 is also configured to: In response to the check result indicating that the target key is in an abnormal state, or the number of errors exceeds a preset threshold, the target key is marked and a replacement index is determined based on the new index and the total number of keys. Then, the key is filtered based on the replacement index and the list of available keys until a usable key is obtained.

[0111] Optionally, the structured prompt module 20 is also configured as follows: The user request is converted into natural language text, and the natural speech text is standardized to obtain standard input text; The standard input text is structured and constrained according to the necessary technical elements to obtain sample prompt words; The prompt word samples are standardized to obtain structured prompt words.

[0112] Optionally, the structured prompt module 20 is also configured as follows: The standard input text is parsed based on the trigger condition elements to obtain the trigger condition features. The trigger condition features are then matched against a preset trigger condition library to obtain the trigger condition. The standard input text is parsed based on the judgment logic elements to obtain the judgment logic features. The judgment logic features are then matched against a preset judgment logic library to obtain the judgment logic. The standard input text is parsed based on the execution action elements to obtain the execution action features. The execution action features are then matched against a preset execution action library to obtain the execution action. The test case generation sentence is determined based on the triggering conditions, judgment logic, and execution actions. The triggering conditions, judgment logic, and execution actions are then integrated based on the determined test case generation sentence to obtain the prompt word sample.

[0113] For ease of description, the above devices are described in terms of function, divided into various modules. Of course, in implementing this application, the functions of each module can be implemented in one or more software and / or hardware.

[0114] The apparatus of the above embodiments is used to implement the corresponding vehicle control command generation method in any of the foregoing embodiments, and has the beneficial effects of the corresponding method embodiments, which will not be repeated here.

[0115] Based on the same inventive concept, corresponding to the methods of any of the above embodiments, this application also provides an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the program to implement the method for generating vehicle control instructions as described in any of the above embodiments.

[0116] Figure 8 This embodiment illustrates a more specific hardware structure of an electronic device. The device may include a processor 1010, a memory 1020, an input / output interface 1030, a communication interface 1040, and a bus 1050. The processor 1010, memory 1020, input / output interface 1030, and communication interface 1040 are interconnected internally via the bus 1050.

[0117] The processor 1010 can be implemented using a general-purpose CPU (Central Processing Unit), microprocessor, application-specific integrated circuit (ASIC), or one or more integrated circuits, and is used to execute relevant programs to implement the technical solutions provided in the embodiments of this specification.

[0118] The memory 1020 can be implemented in the form of ROM (Read Only Memory), RAM (Random Access Memory), static storage device, dynamic storage device, etc. The memory 1020 can store the operating system and other applications. When the technical solutions provided in the embodiments of this specification are implemented by software or firmware, the relevant program code is stored in the memory 1020 and is called and executed by the processor 1010.

[0119] The input / output interface 1030 is used to connect input / output modules to realize information input and output. Input / output modules can be configured as components within the device (not shown in the figure) or externally connected to the device to provide corresponding functions. Input devices may include keyboards, mice, touchscreens, microphones, various sensors, etc., while output devices may include displays, speakers, vibrators, indicator lights, etc.

[0120] The communication interface 1040 is used to connect a communication module (not shown in the figure) to enable communication between this device and other devices. The communication module can communicate via wired means (such as USB, Ethernet cable, etc.) or wireless means (such as mobile network, WIFI, Bluetooth, etc.).

[0121] Bus 1050 includes a pathway for transmitting information between various components of the device, such as processor 1010, memory 1020, input / output interface 1030, and communication interface 1040.

[0122] It should be noted that although the above-described device only shows the processor 1010, memory 1020, input / output interface 1030, communication interface 1040, and bus 1050, in specific implementations, the device may also include other components necessary for normal operation. Furthermore, those skilled in the art will understand that the above-described device may only include the components necessary for implementing the embodiments of this specification, and not necessarily all the components shown in the figures.

[0123] The electronic devices described above are used to implement the corresponding vehicle control command generation method in any of the foregoing embodiments, and have the beneficial effects of the corresponding method embodiments, which will not be repeated here.

[0124] Based on the same inventive concept, corresponding to the methods of any of the above embodiments, this application also provides a non-transitory computer-readable storage medium that stores computer instructions for causing the computer to execute the vehicle control instruction generation method as described in any of the above embodiments.

[0125] The computer-readable medium of this embodiment includes permanent and non-permanent, removable and non-removable media, and information storage can be implemented by any method or technology. Information can be computer-readable instructions, data structures, program modules, or other data. Examples of computer storage media include, but are not limited to, phase-change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, CD-ROM, digital versatile optical disc (DVD) or other optical storage, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other non-transfer medium that can be used to store information accessible by a computing device.

[0126] The computer instructions stored in the storage medium of the above embodiments are used to cause the computer to execute the vehicle control instruction generation method as described in any of the above embodiments, and have the beneficial effects of the corresponding method embodiments, which will not be repeated here.

[0127] Based on the same inventive concept, corresponding to any of the above embodiments, this application also provides a vehicle, including the electronic device or vehicle control command generation device of the above embodiments, and executes the vehicle control command generation method as described in any of the above embodiments through the electronic device or vehicle control command generation device of the above embodiments, and has the beneficial effects of the corresponding method embodiments, which will not be repeated here.

[0128] It is understood that before using the technical solutions of the various embodiments in this application, users will be informed of the type, scope of use, and usage scenarios of the personal information involved in an appropriate manner, and user authorization will be obtained.

[0129] For example, upon receiving a user's active request, a prompt message is sent to the user to explicitly inform them that the requested operation will require the acquisition and use of the user's personal information. This allows the user to independently choose, based on the prompt message, whether to provide personal information to the software or hardware such as electronic devices, applications, servers, or storage media performing the operations described in this application.

[0130] As an optional but not limited implementation, in response to a user's active request, sending a prompt message to the user can be done via a pop-up window, where the prompt message can be presented in text format. Furthermore, the pop-up window can also include a selection control allowing the user to choose "agree" or "disagree" to provide personal information to the electronic device.

[0131] It is understood that the above notification and user authorization process is merely illustrative and does not limit the implementation of this application. Other methods that comply with relevant laws and regulations may also be applied to the implementation of this application.

[0132] Those skilled in the art should understand that the discussion of any of the above embodiments is merely exemplary and is not intended to imply that the scope of this application is limited to these examples; under the concept of this application, the technical features of the above embodiments or different embodiments can also be combined, the steps can be implemented in any order, and there are many other variations of different aspects of the embodiments of this application as described above, which are not provided in detail for the sake of brevity.

[0133] Additionally, to simplify the description and discussion, and to avoid obscuring the embodiments of this application, the well-known power / ground connections to integrated circuit (IC) chips and other components may or may not be shown in the provided drawings. Furthermore, the apparatus may be shown in block diagram form to avoid obscuring the embodiments of this application, and this also takes into account the fact that the details of the implementation of these block diagram apparatuses are highly dependent on the platform on which the embodiments of this application will be implemented (i.e., these details should be fully understood by those skilled in the art). While specific details (e.g., circuits) have been set forth to describe exemplary embodiments of this application, it will be apparent to those skilled in the art that the embodiments of this application can be implemented without these specific details or with variations thereof. Therefore, these descriptions should be considered illustrative rather than restrictive.

[0134] Although this application has been described in conjunction with specific embodiments thereof, many substitutions, modifications, and variations of these embodiments will be apparent to those skilled in the art from the foregoing description. For example, other memory architectures (e.g., dynamic RAM (DRAM)) may be used with the embodiments discussed.

[0135] The embodiments of this application are intended to cover all such substitutions, modifications, and variations that fall within the broad scope of the claims of this application. Therefore, any omissions, modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the embodiments of this application should be included within the protection scope of this application.

Claims

1. A method of generating a vehicle control instruction, characterized by, The method comprises the following steps: In response to receiving a user request, determining a current index corresponding to the user request, and performing dynamic key scheduling according to the current index and a random step to obtain an available key; Structuring the user request according to the prohibited technical features and essential technical elements to obtain a structured prompt word; Generating a control instruction according to the structured prompt word and the available key.

2. The method of generating vehicle control instructions according to claim 1, wherein, The dynamic key scheduling according to the current index and the random step to obtain the available key comprises: Determining the total number of keys according to the available key list and the security constraints; Generating a dynamic random step; Performing random enhancement calculation according to the dynamic random step, the total number of keys and the current index to obtain a new index; Performing key screening according to the new index and the available key list to obtain the available key.

3. The method of generating vehicle control instructions according to claim 2, wherein, The random enhancement calculation according to the dynamic random step, the total number of keys and the current index to obtain a new index comprises: Determining a first jump value according to the dynamic random step and a large prime number; Determining a second jump value according to the current index and the first jump value; Performing modulo operation according to the total number of keys and the second jump value to obtain the new index.

4. The method of generating vehicle control instructions according to claim 2, wherein, The key screening according to the new index and the available key list to obtain the available key comprises: Determining a target key in the available key list according to the new index; Performing key health check on the target key to obtain a check result; In response to the check result being that the target key is in a healthy state, calling an application programming interface according to the target key; In response to the successful calling of the application programming interface, updating the index and returning a response of the key scheduling of the target key as the available key.

5. The method of generating vehicle control instructions according to claim 4, wherein, Further comprising: In response to the calling of the application programming interface failing, performing error counting to obtain an error number; In response to the error number being less than or equal to a preset number threshold, determining a replacement index according to the new index and the total number of keys, and performing key screening according to the replacement index and the available key list until the available key is obtained.

6. The method of generating vehicle control instructions according to claim 5, wherein, Further comprising: In response to the check result being that the target key is in an abnormal state, or the error number being greater than the preset number threshold, marking the target key and determining a replacement index according to the new index and the total number of keys, and performing key screening according to the replacement index and the available key list until the available key is obtained.

7. The method of generating vehicle control instructions according to claim 1, wherein, The structuring the user request according to the prohibited technical features and essential technical elements to obtain a structured prompt word comprises: Converting the user request into a natural language text, and performing standardization processing on the natural language text to obtain a standard input text; Structuring the standard input text according to the essential technical elements to obtain a prompt word example; Performing standardization processing on the prompt word example to obtain the structured prompt word.

8. The method of generating vehicle control instructions according to claim 7, wherein, The necessary technical elements include a trigger condition element, a judgment logic element, and an execution action element; the standard input text is structured and constrained according to the necessary technical elements to obtain a prompt word example, including: The standard input text is parsed according to the trigger condition element to obtain trigger condition features, and the trigger condition features are matched in a preset trigger condition library to obtain a trigger condition; The standard input text is parsed according to the judgment logic element to obtain judgment logic features, and the judgment logic features are matched in a preset judgment logic library to obtain a judgment logic; The standard input text is parsed according to the execution action element to obtain execution action features, and the execution action features are matched in a preset execution action library to obtain an execution action; The trigger condition, the judgment logic, and the execution action are integrated according to a determined use case generation sentence to obtain the prompt word example.

9. An electronic device comprising a memory, a processor, and a computer program stored on the memory and running on the processor, characterized in that, The processor implements the method of any one of claims 1 to 8 when executing the program.

10. A vehicle characterized by comprising: The electronic device of claim 9 is included.

Images