Autonomous guarding method and system based on rule tree

Abstract

The invention relates to the technical field of autonomous guarding based on a rule tree, and discloses an autonomous guarding method and system based on the rule tree, and the method and system achieve the unattended autonomous operation of a training station through the introduction of the rule tree and a behavior logic engine. The dependence of traditional training on a real operator is broken through, the idle time of a training station is effectively shortened, and existing resources are fully utilized; various operation tasks can be automatically executed according to the preset rule tree logic, and the continuity and consistency of the training process are ensured, so that training interruption caused by intermittency of manual operation is avoided, and the continuity of the training tasks is ensured; a dynamic rule reasoning mechanism is adopted, an operation decision path is adjusted through real-time state feedback, the judgment logic and behavior mode of a real operator can be simulated, the system has certain self-adaptability, and the intelligent level of simulation training is improved.

Description

Technical Field

[0001] The present invention relates to the technical field of autonomous guarding based on a rule tree, and in particular to an autonomous guarding method and system based on a rule tree. Background Art

[0002] In existing technologies, simulation training stations primarily rely on human operators to simulate and train tasks. In traditional simulation training systems, operators perform various operations according to training scripts, and the system records the results and adjusts the training process based on the manually input information. Common technical means of this approach include:

[0003] Rely on the operator's real-time response and decision-making to complete tasks, status feedback and other processes.

[0004] The training process is controlled by preset task scripts, so that the system can execute tasks in a fixed logical order.

[0005] In some improved systems, a response mechanism based on condition-action rules is introduced to trigger corresponding actions according to specific conditions, but the rules are relatively static and cannot dynamically adapt to complex situations.

[0006] In some highly intelligent simulation systems, attempts have been made to apply behavior tree models to process complex dynamic behaviors based on logic such as node selection and sequencing. However, these models are primarily used in game AI and robot control and have not yet been widely adopted for intelligent decision-making in simulation training settings.

[0007] Although the above technologies have improved the automation level of simulation training to a certain extent, they still have the following shortcomings when dealing with highly complex, unattended simulation training scenarios:

[0008] The high level of human operator involvement means that training stations are idle during off-hours, making 24 / 7 autonomous training impossible. Pre-set scripts cannot adjust task execution paths based on real-time conditions, resulting in a lack of flexibility in resource utilization.

[0009] Because manual operations rely on the operator's schedule, training is often interrupted, making long-term continuous training impossible. Static rules cannot cope with the dynamic adjustments of the task chain, resulting in poor timeliness in task switching and emergency response.

[0010] Preset scripts can only execute linear task flows and lack intelligent decision-making mechanisms based on logical reasoning, making them unable to simulate the complex thought processes of real operators. While behavior trees offer some dynamic adjustment capabilities, they focus more on the order of behavior execution and lack rule-based reasoning, making it difficult to accurately reflect the operator's logical reasoning and state feedback mechanisms.

[0011] Existing simulation systems often rely on external intervention to evaluate results and lack automated state feedback and adjustment mechanisms. This makes it impossible to implement adaptive adjustments and verification processes based on real-time state changes.

[0012] In summary, existing technologies struggle to balance intelligent decision-making, mission continuity, and resource optimization in unmanned environments. Therefore, there is an urgent need for an autonomous on-duty system based on a dynamic rule tree and behavioral logic engine to enable intelligent decision-making, autonomous training, and closed-loop verification at simulated training stations, thereby improving the system's intelligence and resource utilization. Summary of the Invention

[0013] In view of the above problems, the present invention proposes an autonomous duty method based on a rule tree, including: constructing a rule node structure of condition fields and action fields, and generating a rule tree structure according to the rule node structure and a standard task template.

[0014] A behavioral logic model is constructed based on the rule tree structure. The execution pointer is maintained through the behavioral logic model to control the advancement of the task process. In the multi-task operation scenario, task scheduling and interrupt switching are realized through the task priority management mechanism.

[0015] During the task execution process, state data is collected to form a state vector, and the task process path is dynamically adjusted through the state deviation judgment and correction mechanism.

[0016] Implementing task scheduling and interrupt switching includes organizing state sets, action sets, and state transfer functions in the form of five-tuples through behavioral logic models, maintaining execution pointers to control task process advancement, and introducing a priority management mechanism to implement multi-task scheduling and interrupt switching.

[0017] Dynamically adjusting the task process path includes collecting state parameters to form a state vector, calculating the deviation based on the target state vector, and generating a path adjustment suggestion label when the deviation exceeds the threshold to drive the process optimization strategy.

[0018] As a preferred solution of the rule tree-based autonomous duty method described in the present invention, the rule node structure includes: parsing the task information in the standard task template into multiple rule nodes, each rule node is composed of an input condition field, an action field, a jump target field, a priority field and a node number field, and the input condition field is used to define the status conditions that must be met before the node is activated.

[0019] System status conditions include single sensor value judgment and multi-variable logical combination.

[0020] The action field is used to describe the operation to be performed after the node is activated. The action field includes the operation type, target, and parameter configuration.

[0021] The jump target field is used to specify the next rule node identifier for the process transfer after the condition is met. It supports static numbering and condition-based branch jumps.

[0022] Static numbering includes: Static numbering means directly filling in the number value of the target node. The static number should be consistent with the node number field of the target node, and uniquely locate the rule node during the jump process.

[0023] The exception jump field is used to specify the process to transfer to the exception handling node when the node action fails to execute or the status is abnormal. The value of the exception jump field corresponds to the node number field of the rule node.

[0024] The priority field is of integer type and is used to provide a scheduling basis when multiple tasks are executed in parallel.

[0025] The node number field is a unique identifier used for pointer positioning and status tracking in the execution process.

[0026] The rule node structure parses the task step fields in the template, extracts the trigger conditions, expected actions, and subsequent process branch relationships corresponding to each step of the operation, and maps and fills them into the above fields. After forming a rule node object, it is organized into a node set according to the jump relationship.

[0027] The static ID must be the same as the node ID field value of the target node to ensure jump uniqueness.

[0028] The exception jump field corresponds to the failover field in the standard task template and stores the number of the exception handling node.

[0029] As a preferred solution of the rule-tree-based autonomous duty method described in the present invention, the standard task template includes: the standard task template is organized in a structured data format.

[0030] The standard task template includes a task name field, a starting condition field, an action sequence field, a state judgment field, a jump condition field, a target state field, and an exception handling field.

[0031] The task name field is used to identify the current task scenario and operation target, and the starting condition field lists the state set that the task depends on to start.

[0032] The action sequence field is used to define the operation units to be executed in sequence, the state judgment field is used to set the judgment logic expression after each action, and the jump condition field is used to determine the next operation branch based on the judgment result.

[0033] The target state field is used to set the expected state after the key node is executed.

[0034] The exception handling field is used to define the fault response path and emergency interruption process.

[0035] The standard task template is expressed through a JSON structure and has the ability to nest task steps. Each task step contains four core fields: condition, action, next, and failover, which correspond to the input condition field, action field, jump target field, and exception jump field in the rule node structure. The task step data is read one by one through template parsing, and the rule node structure is automatically generated according to the field value, and a unique number is assigned to each rule node.

[0036] As a preferred solution of the rule tree-based autonomous duty method described in the present invention, the generation of the rule tree structure includes: connecting the rule node structure parsed from the standard task template according to the jump target field, constructing a directed connection relationship, and forming a task-driven rule tree graph structure.

[0037] For task steps that include branch judgment, an independent jump path is automatically generated for each conditional branch and connected to the parent node.

[0038] For the exception handling field, an alternative exception path is constructed in the rule tree structure and connected in parallel with the normal path in a branching manner to generate a complete rule tree structure including a start node, logic branches, conditional jumps and exception paths.

[0039] As a preferred solution of the rule tree-based autonomous duty method described in the present invention, the construction of the behavior logic model includes: mapping the rule nodes in the rule tree structure generated by the standard task template into state nodes in the behavior logic model, using the input condition field of the rule node as the state activation criterion, the action field as the state trigger execution content, the jump target field as the state transfer direction, and constructing a directed state jump structure according to the connection relationship in the rule tree.

[0040] The behavioral logic model includes a state set, an action set, a state transition function, an initial state identifier, and a terminal state set, which are represented by a five-tuple structure.

[0041] The construction process includes assigning a corresponding behavioral state to each rule node, adding the node's action field to the action set, building a state transfer function based on the jump target field and input condition field in the node, and generating a state transfer edge.

[0042] When there are multiple conditional branches in a rule node, a different state transition path is generated for each condition, multiple condition-state pair mapping relationships are added to the state transition function respectively, and the conditional criteria are encoded in a Boolean logic structure and stored in the condition mapping table of the state transition function.

[0043] When a rule node contains an exception handling field, an exception transfer edge is added from the current state node to the exception handling state, and the abnormal transfer behavior is defined through the exception trigger function.

[0044] The exception transfer path is generated based on the exception jump field set in the rule node and is included in the exception state transfer function for unified management. The exception jump relationship has an independent logical priority and can point to the recovery node, termination node, and exception handling node.

[0045] The construction process includes assigning a corresponding behavioral state to each rule node, adding the node's action field to the action set, generating mapping items in the state transfer function based on the jump target field and the input condition field, and generating mapping items of the abnormal state transfer function for rule nodes with abnormal jump fields.

[0046] A complete state transfer network is formed to support normal path jumps, multi-conditional branch control and abnormal path switching.

[0047] During operation, the behavioral logic model maintains the execution pointer to point to the current behavioral state node in real time. In each task execution cycle, the next jump state is determined based on the current state, input conditions and state transfer function, thereby realizing dynamic task advancement, path switching and emergency jump control.

[0048] When a rule node has multiple conditional branches, the behavioral logic model generates an independent state transition path for each condition and embeds the conditional expression into the condition mapping table of the state transition function.

[0049] As a preferred solution of the rule-tree-based autonomous duty method described in the present invention, the maintenance execution pointer controls the advancement of the task process, including setting an execution pointer variable during the task execution process, the execution pointer is used to identify the currently executing state node in real time, and determine the next state node pointed to by the pointer according to the conditional judgment result of the current state node and the state transfer function in the behavioral logic model during the task cycle.

[0050] The pointer execution process includes pointer initialization, state judgment, action triggering, transfer judgment, pointer update and state recording.

[0051] When the task starts, the execution pointer is initialized to the initial state node, and the input condition field corresponding to the current state node is periodically read and compared with the current state vector to determine whether the trigger condition is met.

[0052] When the condition is met, the action execution function is called to issue an operation instruction to the task module, and after the action is executed, the execution pointer is updated according to the state transfer function to point to the next state node.

[0053] When there are multiple jump paths, the path that meets the conditions is selected according to the matching conditions to complete the pointer jump.

[0054] When the action fails to execute or the state deviation exceeds the threshold, the exception handling process is triggered, and the execution pointer is redirected to the specified abnormal state node through the exception jump function, and the emergency response and process rollback logic is entered at the node.

[0055] The emergency response and process rollback logic includes: when the status deviation exceeds the threshold, the processing method is determined according to the configuration policy; when it is set to forced mode, the exception handling process is immediately triggered, and the execution pointer is redirected to the abnormal status node through the exception jump function to enter the emergency response logic.

[0056] When set to suggestion mode, the jump is not triggered immediately, and a path adjustment suggestion label is generated. The path adjustment suggestion label is used to perform path optimization evaluation and jump control.

[0057] The threshold judgment strategy can be configured by the user, supporting static setting of fixed thresholds and dynamically generating difference tolerance ranges based on historical status data.

[0058] If the rule node is configured with an exception jump field, the jump specified by the field will be executed first; otherwise, exception processing will be triggered according to the state deviation.

[0059] The threshold can be dynamically calculated based on a sliding window mean of historical deviation data.

[0060] As a preferred solution of the rule-tree-based autonomous guarding method described in the present invention, the implementation of task scheduling and interrupt switching includes: during the task execution process, binding the current execution pointer state with the task context and saving them uniformly in the task stack structure.

[0061] The task context includes the current state node number, state vector snapshot, pointer jump path sequence and action execution status information.

[0062] In a multi-tasking environment, the scheduler sorts resource allocation based on the priority field value of the task to be executed, and high-priority tasks are given priority in allocating execution channels and computing resources.

[0063] During the task initialization phase, a scheduling queue is generated based on the priority order of the task set, and the concurrent execution of tasks is sorted based on the resource occupancy status.

[0064] The priority field can participate in the scheduler's preemption judgment, interrupt policy decision-making, and task reuse compression mechanism, and takes effect when the task has not yet been executed and is in the pre-scheduling process stage.

[0065] The scheduler compares the priorities of the currently executing task and the tasks to be scheduled in real time. When it detects that a higher priority task enters the execution queue, it interrupts the current task flow, triggers the push-to-save operation, and writes the current context to the stack.

[0066] When a high-priority task is completed and execution is interrupted, the scheduler pops the context information of the suspended task from the stack, rebuilds the pointer state and process path of the task, and repositions the execution pointer to the state node before the interruption, thereby realizing the breakpoint recovery of the original task and the continuation of the task flow.

[0067] The task stack sets a maximum depth threshold. When the stack depth is greater than or equal to the maximum depth threshold, the scheduler handles it according to the configured policy.

[0068] The handling methods include rejecting the new task interrupt request, postponing the scheduling, popping the lowest priority task context and merging it into a summary task.

[0069] Task stack operations use a mutually exclusive access mechanism and support thread locking or atomic operation instructions to achieve concurrent control of context push and pop processes.

[0070] The scheduler performs task integrity checks at each interrupt and resume operation.

[0071] The context save operation must be triggered at the end of the task cycle to ensure that data such as the state vector and pointer position are snapshots at the same moment.

[0072] The priority field is also used for resource allocation sorting in non-interrupt scenarios, and high-priority tasks are given priority in obtaining computing resources.

[0073] As a preferred solution of the rule-tree-based autonomous duty method described in the present invention, the state vector is constructed including: during the task execution process, according to the input condition field set by the current state node, the corresponding state parameter values ​​are collected, and a state vector with a fixed structure is constructed to represent the running state of the current task step.

[0074] Status parameters include temperature, humidity, voltage, current, operation feedback flag, sensor activation status and device response code.

[0075] The elements correspond one-to-one to the input condition fields. The state vector is updated once in each task execution cycle and serves as the basic input for periodic state evaluation.

[0076] As a preferred solution of the rule-tree-based autonomous monitoring method of the present invention, wherein:

[0077] The dynamically adjusting the task process path includes: determining whether path adjustment needs to be triggered during task execution according to a numerical deviation between a current state vector and a target state reference value.

[0078] The current state vector is composed of state parameters collected in real time during task execution.

[0079] State parameters include sensor values, device response codes, and environmental indicators. State parameters are obtained by periodically collecting measurement points mapped to the input condition fields of rule nodes.

[0080] The target state reference value includes: the target state reference value is provided by the target state field in the standard task template, and is calculated by the cluster mean of the normally completed state vector in the preset task rules and the historical execution trajectory.

[0081] When the deviation value exceeds the predefined error threshold, the configured threshold triggers the policy and generates a path adjustment suggestion label in suggestion mode.

[0082] The deviation value is the Euclidean distance between the current state vector and the target state reference value. The difference between each component in the state vector and the target state component is squared, and then the sum is taken and the square root is taken to obtain the overall deviation degree.

[0083] The deviation is executed once after the state vector is updated in each cycle to ensure that the data source is consistent with the calculation benchmark and avoid logical errors caused by cross-cycle or recalculation.

[0084] Path adjustment suggestion tags include allowing fallback, branch switching, and task suspension, but do not directly trigger jumps and only serve as input for path control.

[0085] In the forced mode, the deviation behavior is used as the entry point for abnormal event processing, and the abnormal state transfer process is directly executed.

[0086] The threshold triggering strategy is a configurable item. It is defined as suggestion priority in the initialization phase to ensure that the path adjustment mechanism and abnormal jump behavior maintain a mutually exclusive and non-conflicting response order in the scheduling process.

[0087] The target state vector is loaded from the standard task template during task initialization and can be dynamically adjusted according to historical success states during execution.

[0088] Deviation calculation is performed immediately after the state vector is updated to ensure data timeliness.

[0089] The threshold can be dynamically calculated based on a sliding window mean of historical deviation data.

[0090] A rule-tree-based autonomous guarding system is characterized by comprising a rule-tree construction module, a behavior execution control module, and a state perception and path adjustment module.

[0091] The rule tree construction module is used to construct a rule node structure of a condition field and an action field, and generate a rule tree structure according to the rule node structure and a standard task template.

[0092] The behavior execution control module is used to build a behavior logic model based on the rule tree structure, maintain the execution pointer through the behavior logic model to control the task process advancement, and realize task scheduling and interrupt switching through the task priority management mechanism in a multi-task running scenario.

[0093] The state perception and path adjustment module is used to collect state data to form a state vector during task execution, and dynamically adjust the task process path through a state deviation judgment and correction mechanism.

[0094] The beneficial effects of the present invention are as follows: by introducing a rule tree and a behavior logic engine, unattended autonomous operation of the training station is realized, breaking the dependence of traditional training on real operators, effectively reducing the idle time of the training station, and making full use of existing resources.

[0095] The system can automatically execute various operational tasks according to the preset rule tree logic to ensure the continuity and consistency of the training process, thereby avoiding training interruptions caused by intermittent manual operations and ensuring the continuity of training tasks.

[0096] By adopting a dynamic rule reasoning mechanism and adjusting the operation decision path through real-time status feedback, it can simulate the judgment logic and behavior patterns of real operators, make the system have a certain degree of adaptability, and improve the intelligence level of simulation training.

[0097] The system integrates status monitoring and feedback mechanisms, performs status assessment and decision adjustments after each operation, forming a complete closed-loop verification chain. It can promptly detect and correct erroneous operations, thereby improving the accuracy and reliability of training.

[0098] The decision path based on the rule tree has a clear "condition-action" logic chain. Compared with the behavior tree, it is more in line with the characteristics of clear tasks and fixed processes in simulation training stations, making the operation logic clear and transparent, and facilitating system debugging and expansion.

[0099] The rule tree model has a modular structure and can flexibly adjust or add rule nodes according to training task requirements, making the system highly scalable and maintainable, which is helpful for subsequent function upgrades and expansions. BRIEF DESCRIPTION OF THE DRAWINGS

[0100] To more clearly illustrate the technical solutions of the embodiments of the present invention, the following briefly introduces the drawings required for describing the embodiments. Obviously, the drawings described below are only some embodiments of the present invention. Those skilled in the art can also derive other drawings based on these drawings without inventive effort. Among them:

[0101] Figure 1 The overall flow chart of a rule-tree-based autonomous monitoring method and system provided in the first embodiment of the present invention; DETAILED DESCRIPTION

[0102] To make the above-mentioned objects, features, and advantages of the present invention more clearly understood, the following detailed description of the specific embodiments of the present invention is given in conjunction with the accompanying drawings. It is obvious that the described embodiments are only part of the embodiments of the present invention, not all of them. Based on the embodiments of the present invention, all other embodiments obtained by ordinary persons in this field without creative work should fall within the scope of protection of the present invention.

[0103] Example 1, with reference to Figure 1 , as an embodiment of the present invention, provides an autonomous guarding method based on a rule tree, comprising:

[0104] S1: Construct the rule node structure of the condition field and the action field, and generate the rule tree structure according to the rule node structure and the standard task template.

[0105] The task information in the standard task template is parsed into multiple rule nodes. Each rule node consists of an input condition field, an action field, a jump target field, a priority field, and a node number field. The input condition field defines the status conditions that must be met before the node is activated.

[0106] System status conditions include single sensor value judgment and multi-variable logical combination.

[0107] The action field is used to describe the operation to be performed after the node is activated. The action field includes the operation type, target, and parameter configuration.

[0108] The jump target field is used to specify the next rule node ID to which the process will transfer after the condition is met. It supports static numbering or condition-based branch jumps.

[0109] The priority field is of integer type and is used to provide a scheduling basis when multiple tasks are executed in parallel.

[0110] The node number field is a unique identifier used for pointer positioning and status tracking in the execution process.

[0111] The rule node structure parses the task step fields in the template, extracts the trigger conditions, expected actions, and subsequent process branch relationships corresponding to each step of the operation, and maps and fills them into the above fields. After forming a rule node object, it is organized into a node set according to the jump relationship.

[0112] Furthermore, standard task templates are organized in a structured data format.

[0113] The standard task template includes a task name field, a starting condition field, an action sequence field, a state judgment field, a jump condition field, a target state field, and an exception handling field.

[0114] The task name field is used to identify the current task scenario and operation target, and the starting condition field lists the state set that the task depends on to start.

[0115] The action sequence field is used to define the operation units to be executed in sequence, the state judgment field is used to set the judgment logic expression after each action, and the jump condition field is used to determine the next operation branch based on the judgment result.

[0116] The target state field is used to set the expected state after the key node is executed.

[0117] The exception handling field is used to define the fault response path and emergency interruption process.

[0118] The standard task template is expressed through a JSON structure and has the ability to nest task steps. Each task step contains four core fields: condition, action, next, and failover, which correspond to the input condition field, action field, jump target field, and exception jump field in the rule node structure. The task step data is read one by one through template parsing, and the rule node structure is automatically generated according to the field value, and a unique number is assigned to each rule node.

[0119] Furthermore, the rule node structure obtained by parsing the standard task template is path-connected according to the jump target field to construct a directed connection relationship and form a task-driven rule tree graph structure.

[0120] For task steps that include branch judgment, an independent jump path is automatically generated for each conditional branch and connected to the parent node.

[0121] For the exception handling field, an alternative exception path is constructed in the rule tree structure and connected in parallel with the normal path in a branching manner to generate a complete rule tree structure including a start node, logic branches, conditional jumps and exception paths.

[0122] S2: Build a behavioral logic model based on the rule tree structure, maintain the execution pointer through the behavioral logic model to control the task process advancement, and implement task scheduling and interrupt switching through the task priority management mechanism in multi-tasking operation scenarios.

[0123] The rule nodes in the rule tree structure generated by the standard task template are mapped to state nodes in the behavior logic model.

[0124] A preferred solution for mapping to state nodes in the behavioral logic model is:

[0125] s i =φ(n i )

[0126] Among them, s i Indicates the state node number in the behavioral logic model, n i Represents the rule node number in the rule tree, and φ represents the mapping function from rule node to state node.

[0127] The input condition field of the rule node is used as the state activation criterion, the action field is used as the state trigger execution content, the jump target field is used as the state transfer direction, and a directed state jump structure is constructed according to the connection relationship in the rule tree.

[0128] The behavioral logic model includes a state set, an action set, a state transition function, an initial state identifier, and a terminal state set, which are represented by a five-tuple structure.

[0129] The construction process includes assigning a corresponding behavioral state to each rule node, adding the node's action field to the action set, building a state transfer function based on the jump target field and input condition field in the node, and generating a state transfer edge.

[0130] A preferred solution for generating state transition edges is:

[0131] δ(s i ,c k )=s j

[0132] Among them, δ represents the state transfer function, s i Indicates the current state node, c k Indicates the input condition field, s j Indicates the target state node after the transition.

[0133] When there are multiple conditional branches in a rule node, a different state transfer path is generated for each condition, and the conditional expression is used as the transfer criterion and embedded in the transfer function table of the model.

[0134] When a rule node contains an exception handling field, an exception transfer edge is added from the current state node to the exception handling state, and the abnormal transfer behavior is defined through the exception trigger function.

[0135] A preferred solution for defining abnormal transfer behavior is:

[0136] δ f (s i ,e k )=s e

[0137] Among them, δ f Indicates the abnormal state jump function, s i Indicates the current state node, e k Indicates abnormal triggering conditions, s e Indicates the target abnormal status node.

[0138] Abnormal status can be further pointed to recovery nodes and termination nodes to achieve task process interruption, rollback, and safe termination.

[0139] During operation, the behavioral logic model maintains the execution pointer to point to the current behavioral state node in real time. In each task execution cycle, the next jump state is determined based on the current state, input conditions and state transfer function, thereby realizing dynamic task advancement, path switching and emergency jump control.

[0140] The execution pointer state change record is used to support the execution of task backtracking, priority switching, and path correction strategies.

[0141] Furthermore, an execution pointer variable is set during the task execution process. The execution pointer is used to identify the currently executing state node in real time, and determine the next state node pointed to by the pointer based on the conditional judgment result of the current state node and the state transfer function in the behavioral logic model during the task cycle.

[0142] A preferred solution for determining the next state node pointed to by the pointer is:

[0143]

[0144] Among them, Ptr t+1 Indicates the execution pointer position at time t+1 of the task cycle, s t Indicates the state node of the current cycle, represents the set of conditional fields that are successfully matched in period t, and δ represents the state transition function.

[0145] The pointer execution process includes pointer initialization, state judgment, action triggering, transfer judgment, pointer update and state recording.

[0146] When the task starts, the execution pointer is initialized to the initial state node, and the input condition field corresponding to the current state node is periodically read and compared with the current state vector to determine whether the trigger condition is met.

[0147] When the condition is met, the action execution function is called to issue an operation instruction to the task module, and after the action is executed, the execution pointer is updated according to the state transfer function to point to the next state node.

[0148] When there are multiple jump paths, the path that meets the conditions is selected according to the matching conditions to complete the pointer jump;

[0149] When the action fails to execute or the state deviation exceeds the threshold, the exception handling process is triggered, and the execution pointer is redirected to the specified abnormal state node through the exception jump function, and the emergency response and process rollback logic is entered at the node.

[0150] Furthermore, during the task execution process, the current execution pointer state is bound to the task context and saved and uniformly stored in the task stack structure.

[0151] The task context includes the current state node number, state vector snapshot, pointer jump path sequence and action execution status information.

[0152] In a multi-tasking environment, the scheduler compares the priorities of the currently executing task and the tasks to be scheduled in real time. When it detects that a higher priority task enters the execution queue, it interrupts the current task flow, triggers the push-to-save operation, and writes the current context to the stack.

[0153] A preferred solution for interrupting the current task flow is:

[0154]

[0155] Among them, P new Indicates the priority value of the newly entered task, P current Indicates the priority of the currently executing task, and TriggerInterrupt indicates the scheduling behavior of interrupting the current task and saving the context.

[0156] When a high-priority task is completed and execution is interrupted, the scheduler pops the context information of the suspended task from the stack, rebuilds the pointer state and process path of the task, and repositions the execution pointer to the state node before the interruption, thereby realizing the breakpoint recovery of the original task and the continuation of the task flow.

[0157] S3: During the task execution process, state data is collected to form a state vector, and the task process path is dynamically adjusted through the state deviation judgment and correction mechanism.

[0158] During the task execution process, the corresponding state parameter values ​​are collected according to the input condition fields set by the current state node, and a state vector with a fixed structure is constructed to represent the running state of the current task step.

[0159] A preferred solution for constructing a state vector with a fixed structure is:

[0160]

[0161] in, represents the current state vector of task cycle t, represents the measured value of the i-th state parameter in period t, and n represents the n-th state parameter.

[0162] Status parameters include temperature, humidity, voltage, current, operation feedback flag, sensor activation status and device response code.

[0163] The elements correspond one-to-one to the input condition fields. The state vector is updated once in each task execution cycle and serves as the basic input for periodic state evaluation.

[0164] Furthermore, according to the numerical deviation between the current state vector and the target state reference value, it is determined whether the path adjustment needs to be triggered during the task execution process.

[0165] A preferred solution for the target state reference value is:

[0166]

[0167] in, represents the desired target state vector, represents the target setting value of the i-th state field, and n represents the n-th state parameter.

[0168] A preferred solution for determining whether path adjustment needs to be triggered during task execution is:

[0169]

[0170] Among them, Δ t express, represents the current state vector of task cycle t, represents the expected target state vector, and ||·||2 represents the Euclidean norm.

[0171] When the deviation value exceeds the predefined error threshold, a path adjustment suggestion label is generated based on the preconfigured path evaluation rules.

[0172] A preferred solution for predefining the error threshold is:

[0173]

[0174] Among them, Δ t represents the current state deviation, θ t Indicates the deviation threshold of the tth cycle, Generate-Tag t Indicates the triggering action for generating path adjustment suggestion labels.

[0175] A preferred solution for generating path adjustment suggestion labels is:

[0176] Tags t =Π(s t ,Δ t )

[0177] Among them, Tags t represents the path suggestion label generated in the tth cycle, Π(·) represents the path optimization strategy function, and s t represents the current state node, Δ t Indicates the current state deviation value.

[0178] The path adjustment suggestion label includes an item that allows you to go back, switch branches, or pause the task.

[0179] The path adjustment suggestion label does not directly trigger the path jump. It serves as the input of the path control module to perform a state-driven task process optimization suggestion generation mechanism.

[0180] The above embodiment also includes an autonomous guarding system based on a rule tree, specifically:

[0181] Rule tree construction module 100, behavior execution control module 200, state perception and path adjustment module 300.

[0182] The rule tree construction module 100 is used to construct a rule node structure of a condition field and an action field, and generate a rule tree structure according to the rule node structure and a standard task template.

[0183] The behavior execution control module 200 is used to build a behavior logic model based on the rule tree structure, maintain the execution pointer through the behavior logic model to control the task process advancement, and realize task scheduling and interrupt switching through the task priority management mechanism in a multi-task running scenario.

[0184] The state perception and path adjustment module 300 is used to collect state data to form a state vector during task execution, and dynamically adjust the task process path through a state deviation judgment and correction mechanism.

[0185] Example 2, referring to the autonomous guarding based on the rule tree, is an embodiment of the present invention, which provides an autonomous guarding method and system based on the rule tree. In order to verify the beneficial effects of the present invention, scientific demonstration is carried out through simulation experiments.

[0186] This simulates the task-driven operational processes in industrial equipment management systems by defining a standard task template in JSON format. It automatically parses the task structure and constructs a set of rule nodes. Each node contains input condition fields, action fields, jump target fields, priority fields, and a unique number field, depending on the task settings.

[0187] After template parsing, a logically complete directed rule tree structure is generated based on jump relationships and input into the behavioral logic model generation unit for mapping and construction. Each rule node is assigned a state number and bound to a state transition function, forming a state-action-path ternary structure. The behavioral model controls the advancement of the execution pointer, determining the task flow path and execution logic by determining state matching and conditional criteria in each cycle. During the task execution, device operation data is continuously collected to form a standardized state vector. Path adjustment suggestion tags are triggered when state deviations exceed a threshold.

[0188] The experimental design includes six independent tasks, covering different starting states, priorities, and target states. During the experiment, the distance between the current state and the target state is dynamically evaluated, and behavioral recommendations are generated based on rules. The interrupt mechanism and task priority switching logic are triggered in tasks T003 and T006 to verify the interrupt stack push and context restore functions. In scenarios with large task deviations, path adjustment recommendations for pauses and switch branches are effectively generated.

[0189] All experiments were conducted within the simulation platform. State parameters were collected once per cycle. Abnormal events were injected by the random perturbation module and bound to the exception handling path. Task execution results, including execution success rate, number of adjustments, and number of task interruptions and resumes, were recorded in a table for analysis. The experimental data is shown in Table 1.

[0190] Table 1 Experimental data table

[0191]

[0192] As can be seen from the table, task T001, T004, and T006 encountered path adjustment tags during execution. T001 automatically adjusted its branch path under moderate deviations, maintaining a 95% success rate. This demonstrates that the proposed path switching strategy can achieve local optimization and correction without interrupting the overall process. Task T004 successfully triggered the fallback strategy and smoothly entered the fallback path recovery process during execution, ultimately achieving a 92% task success rate, surpassing the stability of traditional non-fallback processes.

[0193] In contrast, tasks T003 and T006, despite having high priority, triggered the execution interrupt mechanism when their state deviated significantly. In particular, T003 was identified by the system as being in a risky state, triggering a pause flag and automatically performing a stack save and task caching. During recovery, the task reloaded its context, rebuilt its execution path, and entered the safe jump logic. Although the task execution success rate dropped to 76%, no abnormal exits occurred, demonstrating that the combined operation of the abnormal state jump function and the priority switching mechanism ensured task integrity.

[0194] Tasks T002 and T005, serving as control groups, exhibited stable success rates of 88% and 85% when the deviation value was less than 0.1 and no path adjustment was made. This confirms that in scenarios where the path remains unchanged, execution results are primarily influenced by the complexity of the task structure and the success rate of the action.

[0195] From the overall trend, when the task state deviation exceeds 0.2, the path adjustment suggestion mechanism has a significant intervention effect. It can generate reasonable labels based on the current state node and the deviation value, and cooperate with the state transition function in the behavioral logic model to trigger actions and pointer updates, thereby optimizing path selection.

[0196] Example 3, referring to the autonomous guarding based on the rule tree, is an embodiment of the present invention, which provides an autonomous guarding system based on the rule tree, including: a rule tree construction module 100, a behavior execution control module 200, and a state perception and path adjustment module 300.

[0197] Among them, S4: the rule tree construction module 100 is used to construct the rule node structure of the condition field and the action field, and generate the rule tree structure according to the rule node structure and the standard task template.

[0198] It should also be noted that the rule tree construction module 100, as the starting point for task flow modeling, first constructs a rule tree structure consisting of multiple rule nodes based on a standard task template. Each rule node contains an input condition field, an action field, a jump target field, and other content, forming a structured logical path for task execution.

[0199] S5: The behavior execution control module 200 is used to build a behavior logic model based on the rule tree structure, maintain the execution pointer through the behavior logic model to control the task process advancement, and implement task scheduling and interrupt switching through the task priority management mechanism in a multi-task running scenario.

[0200] It should also be noted that the behavior execution control module 200 maintains the execution pointer during the task execution process and promotes the task process according to the state transition function.

[0201] S6: The state perception and path adjustment module 300 is used to collect state data to form a state vector during task execution, and dynamically adjust the task process path through a state deviation judgment and correction mechanism.

[0202] It should also be noted that the state perception and path adjustment module 300 performs difference calculation based on the collected state vector and the preset target state value, generates state deviation information, and feeds it back to the behavior execution control module 200.

[0203] If the function is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention, or the part that contributes to the existing technology, or the part of the technical solution, can be embodied in the form of a software product. The computer software product is stored in a storage medium and includes a number of instructions for enabling a computer device (which can be a personal computer, server, or network device, etc.) to execute all or part of the steps of the various embodiments of the method of the present invention. The aforementioned storage medium includes: U disk, mobile hard disk, read-only memory (ROM, Read-Only Memory), random access memory (RAM, Random Access Memory), disk or optical disk, and other media that can store program code.

[0204] The logic and / or steps represented in the flowcharts or otherwise described herein, for example, can be considered as an ordered list of executable instructions for implementing the logical functions, and can be embodied in any computer-readable medium for use by, or in conjunction with, an instruction execution system, apparatus, or device (e.g., a computer-based system, a system including a processor, or other system that can fetch and execute instructions from an instruction execution system, apparatus, or device). For purposes of this specification, a "computer-readable medium" can be any device that can contain, store, communicate, propagate, or transport a program for use by, or in conjunction with, an instruction execution system, apparatus, or device.

[0205] More specific examples (a non-exhaustive list) of computer-readable media include the following: an electrical connection with one or more wires (electronic devices), a portable computer disk cartridge (magnetic devices), a random access memory (RAM), a read-only memory (ROM), an erasable and programmable read-only memory (EPROM or flash memory), a fiber optic device, and a portable compact disc read-only memory (CDROM). In addition, the computer-readable medium may even be paper or other suitable medium on which the program is printed, since the program may be obtained electronically, for example, by optically scanning the paper or other medium, followed by editing, deciphering, or processing in another suitable manner as necessary, and then stored in a computer memory.

[0206] It should be understood that various parts of the present invention can be implemented using hardware, software, firmware, or a combination thereof. In the above-described embodiments, multiple steps or methods can be implemented using software or firmware stored in a memory and executed by a suitable instruction execution system. For example, if implemented using hardware, as in another embodiment, any one of the following technologies known in the art or a combination thereof can be used: a discrete logic circuit having logic gate circuits for implementing logical functions on data signals, an application-specific integrated circuit having suitable combinational logic gate circuits, a programmable gate array (PGA), a field-programmable gate array (FPGA), etc. It should be noted that the above embodiments are merely illustrative of the technical solutions of the present invention and are not intended to be limiting. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that the technical solutions of the present invention may be modified or replaced with equivalents without departing from the spirit and scope of the technical solutions of the present invention, and all such modifications should be encompassed by the claims of the present invention.

[0207] It should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit the present invention. Although the present invention has been described in detail with reference to the preferred embodiments, those skilled in the art should understand that the technical solutions of the present invention may be modified or replaced by equivalents without departing from the spirit and scope of the technical solutions of the present invention, which should all be included in the scope of the claims of the present invention.

Claims

1. An autonomous guarding method based on a rule tree, characterized in that: include: Build the rule node structure of condition fields and action fields, and generate the rule tree structure according to the rule node structure and standard task template; Build a behavior logic model based on the rule tree structure, maintain the execution pointer through the behavior logic model to control the task process, and implement task scheduling and interrupt switching through the task priority management mechanism in multi-task operation scenarios; During the task execution process, state data is collected to form a state vector, and the task process path is dynamically adjusted through the state deviation judgment and correction mechanism; Implementing task scheduling and interrupt switching involves organizing state sets, action sets, and state transition functions in the form of five-tuples through a behavioral logic model, maintaining execution pointers to control task flow, and introducing a priority management mechanism to implement multi-task scheduling and interrupt switching. Dynamically adjusting the task process path includes collecting state parameters to form a state vector, calculating the deviation based on the target state vector, and generating a path adjustment suggestion label when the deviation exceeds the threshold to drive the process optimization strategy.

2. The rule-tree-based autonomous monitoring method according to claim 1, wherein: The rule node structure includes: Parse the task information in the standard task template into multiple rule nodes. Each rule node consists of an input condition field, an action field, a jump target field, a priority field, and a node number field. The input condition field defines the status conditions that must be met before the node is activated. System status conditions include single sensor value judgment and multi-variable logical combination; The action field is used to describe the operation to be performed after the node is activated. The action field includes the operation type, target, and parameter configuration; The jump target field is used to specify the next rule node ID to which the process will transfer after the condition is met. It supports static numbering and condition-based branch jumps. Static numbering includes: Static numbering means directly filling in the target node's number value. The static number should be consistent with the node number field of the target node, and uniquely locate the rule node during the jump process; The exception jump field is used to specify the process to transfer to the exception handling node when the node action fails to execute or the status is abnormal. The value of the exception jump field corresponds to the node number field of the rule node; The priority field is an integer type and is used to provide a scheduling basis when multiple tasks are executed in parallel; The node number field is a unique identifier used for pointer positioning and status tracking in the execution process; The rule node structure parses the task step fields in the template, extracts the trigger conditions, expected actions, and subsequent process branch relationships corresponding to each step of the operation, and maps and fills them into the above fields. After forming a rule node object, it is organized into a node set according to the jump relationship.

3. The rule-tree-based autonomous monitoring method according to claim 2, wherein: The standard task templates include: Standard task templates are organized in a structured data format; The standard task template includes the task name field, the starting condition field, the action sequence field, the status judgment field, the jump condition field, the target status field and the exception handling field; The task name field is used to identify the current task scenario and operation target, and the starting condition field lists the state set that the task depends on to start; The action sequence field is used to define the operation units to be executed in sequence, the state judgment field is used to set the judgment logic expression after each action, and the jump condition field is used to determine the next operation branch based on the judgment result; The target state field is used to set the expected state after the key node is executed; The exception handling field is used to define the fault response path and emergency interruption process; The standard task template is expressed through a JSON structure and has the ability to nest task steps. Each task step contains four core fields: condition, action, next, and failover, which correspond to the input condition field, action field, jump target field, and exception jump field in the rule node structure. The task step data is read one by one through template parsing, and the rule node structure is automatically generated according to the field value, and a unique number is assigned to each rule node.

4. The rule-tree-based autonomous monitoring method according to claim 3, wherein: The generation rule tree structure includes: The rule node structure parsed from the standard task template is connected by paths according to the jump target field, and a directed connection relationship is constructed to form a task-driven rule tree graph structure; For task steps that include branch judgment, an independent jump path is automatically generated for each conditional branch and connected to the parent node; For the exception handling field, an alternative exception path is constructed in the rule tree structure and connected in parallel with the normal path in a branching manner to generate a complete rule tree structure including a start node, logic branches, conditional jumps and exception paths.

5. The rule-tree-based autonomous monitoring method according to claim 4, characterized in that: The constructing of the behavior logic model includes: Map the rule nodes in the rule tree structure generated by the standard task template to state nodes in the behavior logic model. Use the input condition field of the rule node as the state activation criterion, the action field as the state trigger execution content, and the jump target field as the state transfer direction. Then, construct a directed state jump structure according to the connection relationship in the rule tree. The behavior logic model includes a state set, an action set, a state transition function, an initial state identifier, and a terminal state set, which are represented by a five-tuple structure. The construction process includes assigning a corresponding behavior state to each rule node, adding the node's action field to the action set, building a state transition function based on the jump target field and input condition field in the node, and generating a state transition edge; When there are multiple conditional branches in a rule node, a different state transition path is generated for each condition, multiple condition-state pair mapping relationships are added to the state transition function respectively, and the conditional criteria are encoded in a Boolean logic structure and stored in the condition mapping table of the state transition function; When a rule node contains an exception handling field, an exception transfer edge is added from the current state node to the exception handling state, and abnormal transfer behavior is defined through the exception trigger function; The exception transfer path is generated based on the exception jump field set in the rule node and is included in the exception state transfer function for unified management. The exception jump relationship has independent logical priority and can point to the recovery node, termination node, and exception handling node; The construction process includes assigning a corresponding behavior state to each rule node, adding the node's action field to the action set, generating mapping items in the state transfer function based on the jump target field and the input condition field, and generating mapping items of the abnormal state transfer function for rule nodes with abnormal jump fields; Form a complete state transfer network that supports normal path jumps, multi-conditional branch control, and abnormal path switching; The behavioral logic model maintains an execution pointer during operation, pointing to the current behavior state node in real time. In each task execution cycle, the next jump state is determined based on the current state, input conditions, and state transition function, thus achieving dynamic task advancement, path switching, and emergency jump control. The execution pointer state change record is used to support the execution of task backtracking, priority switching, and path correction strategies.

6. The rule-tree-based autonomous monitoring method according to claim 5, characterized in that: The maintenance execution pointer control task process advancement includes: During the task execution process, the execution pointer variable is set. The execution pointer is used to identify the currently executed state node in real time and determine the next state node to which the pointer points based on the condition judgment result of the current state node and the state transfer function in the behavior logic model during the task cycle. The pointer execution process includes pointer initialization, state judgment, action triggering, transfer judgment, pointer update and state recording; When the task starts, the execution pointer is initialized to the initial state node, and the input condition field corresponding to the current state node is periodically read and compared with the current state vector to determine whether the trigger condition is met; When the condition is met, the action execution function is called to issue an operation instruction to the task module, and after the action is executed, the execution pointer is updated according to the state transfer function to point to the next state node; When there are multiple jump paths, the path that meets the conditions is selected according to the matching conditions to complete the pointer jump; When an action fails to execute or the state deviation exceeds the threshold, the exception handling process is triggered. The execution pointer is redirected to the specified abnormal state node through the exception jump function, and the emergency response and process rollback logic are entered at the node. The emergency response and process rollback logic includes: when the state deviation exceeds the threshold, the handling method is determined according to the configuration policy. When the forced mode is set, the exception handling process is immediately triggered, and the execution pointer is redirected to the abnormal state node through the exception jump function to enter the emergency response logic; When set to suggestion mode, the redirect is not triggered immediately, but a path adjustment suggestion label is generated. Path optimization evaluation and jump control are performed based on the path adjustment suggestion label. The threshold judgment strategy can be configured by the user, supporting static setting of fixed thresholds and dynamically generating difference tolerance ranges based on historical status data.

7. The rule-tree-based autonomous monitoring method according to claim 6, wherein: The implementation of task scheduling and interrupt switching includes: During the task execution process, the current execution pointer state is bound to the task context and saved in the task stack structure. The task context includes the current state node number, state vector snapshot, pointer jump path sequence and action execution status information; In a multi-tasking environment, the scheduler sorts resource allocation based on the priority field value of the tasks to be executed, and high-priority tasks are given priority in allocating execution channels and computing resources; In the task initialization phase, a scheduling queue is generated based on the priority order of the task set, and the concurrent execution of tasks is sorted based on the resource occupancy status; The priority field can participate in the scheduler's preemption judgment, interruption policy decision-making, and task reuse compression mechanism. It takes effect when the task has not yet been executed and is in the pre-scheduling process stage. The scheduler compares the priorities of the currently executing task and the tasks to be scheduled in real time. When it detects that a higher priority task has entered the execution queue, it interrupts the current task flow, triggers a push-to-save operation, and writes the current context to the stack. When a high-priority task is completed and execution is interrupted, the scheduler pops the context information of the suspended task from the stack, rebuilds the task pointer state and process path, and repositions the execution pointer to the state node before the interruption, realizing the breakpoint recovery of the original task and the continuation of the task flow; The task stack sets a maximum depth threshold. When the stack depth is greater than or equal to the maximum depth threshold, the scheduler handles it according to the configured policy. The handling methods include rejecting the new task interrupt request, postponing the scheduling, popping the lowest priority task context and merging it into a summary task; Task stack operations use a mutually exclusive access mechanism and support thread locking or atomic operation instructions to achieve concurrent control of context push and pop processes; The scheduler performs task integrity checks at each interrupt and resume operation.

8. The rule-tree-based autonomous monitoring method according to claim 7, wherein: The state vector is composed of: During the task execution process, according to the input condition field set by the current state node, the corresponding state parameter value is collected and a state vector with a fixed structure is constructed to represent the running state of the current task step; Status parameters include temperature, humidity, voltage, current, operation feedback flag, sensor activation status and device response code; The elements correspond one-to-one to the input condition fields. The state vector is updated once in each task execution cycle and serves as the basic input for periodic state evaluation.

9. The rule-tree-based autonomous monitoring method according to claim 8, characterized in that: The dynamic adjustment of the task flow path includes: According to the numerical deviation between the current state vector and the target state reference value, it is determined whether the path adjustment needs to be triggered during the task execution; The current state vector is composed of state parameters collected in real time during task execution; State parameters include sensor values, device response codes, and environmental indicators. State parameters are obtained by periodically collecting measurement points mapped to the input condition fields of rule nodes. The target state reference value includes: the target state reference value is provided by the target state field in the standard task template, and is calculated by the cluster mean of the normally completed state vector in the preset task rules and the historical execution trajectory; When the deviation value exceeds the predefined error threshold, the configured threshold triggers the policy and generates a path adjustment suggestion label in suggestion mode; The deviation value is the Euclidean distance between the current state vector and the target state reference value. The difference between each component in the state vector and the target state component is squared, and then the sum is taken and the square root is taken to obtain the overall deviation degree. The deviation is executed once in each cycle after the state vector is updated. This ensures that the data source is consistent with the calculation benchmark and avoids logical errors caused by cross-cycle or recalculation. Path adjustment suggestion tags include allowing fallback, branch switching, and task suspension, but do not directly trigger jumps and only serve as input for path control; In the mandatory mode, the deviation behavior is used as the entry point for abnormal event processing, and the abnormal state transfer process is directly executed; The threshold triggering strategy is a configurable item. It is defined as suggestion priority in the initialization phase to ensure that the path adjustment mechanism and abnormal jump behavior maintain a mutually exclusive and non-conflicting response order in the scheduling process.

10. An autonomous guarding system based on a rule tree, characterized by: It includes a rule tree construction module (100), a behavior execution control module (200), and a state perception and path adjustment module (300); The rule tree construction module (100) is used to construct a rule node structure of a condition field and an action field, and generate a rule tree structure according to the rule node structure and a standard task template; The behavior execution control module (200) is used to construct a behavior logic model according to a rule tree structure, control the advancement of task processes through maintaining execution pointers in the behavior logic model, and implement task scheduling and interrupt switching through a task priority management mechanism in a multi-task operation scenario; The state perception and path adjustment module (300) is used to collect state data to form a state vector during task execution, and dynamically adjust the task process path through a state deviation judgment and correction mechanism.

Images