首页 理论 架构 工程 规划 文档 白皮书 著作 研究 案例 下载 博客 关于 联系 开始使用 →

第三十章 个体自主运行程序实现

第三十章 个体自主运行程序实现

  1. 个体任务接收与运行流程

  2. 个体内部处理程序的组织

  3. 自主运行与方法执行的衔接

  4. 运行过程记录与状态更新

  5. 个体自主运行闭环测试

    第三十章 个体自主运行程序实现

    个体自主运行判断解决的是个体在接收任务后能否进入自主运行的问题。第二十九章已经从任务与能力匹配、运行条件、个体状态、执行约束和异常情况等方面建立了自主运行判断机制。本章进一步研究如何将判断结果转化为实际程序执行过程,完成任务接收、运行初始化、内部程序调度、知识能力调用、方法执行衔接、运行状态更新以及全过程验证。

    个体自主运行不是简单地接收一个任务指令,然后调用某个程序完成操作。一个完整的自主运行过程,需要将任务定义、个体身份、知识能力赋值、运行上下文、对象信息、执行规则和运行结果组织为具有连续关系的程序过程。任务进入个体运行环境后,首先需要形成任务实例,再由运行引擎根据任务要求组织内部处理程序,经过能力调用和运行判断后进入相应的执行环节。执行过程中产生的信息、状态和结果必须能够被记录,并且能够支持任务继续、暂停、恢复、结束或异常处理。

    从WSaiOS工程总体结构看,个体自主运行程序与智能控制后台承担不同的工程职责。智能控制后台负责需求驱动、知识结构化构建、知识能力形成与验证、个体智能赋值、项目规划和多智能个体组织控制。个体自主运行程序负责在已经获得的知识结构、知识能力、方法和执行规则范围内处理具体任务。个体可以根据本地对象信息、运行条件和任务状态进行自主判断与处理,但不需要复制智能控制后台的完整结构智能逻辑和知识构建机制。

    本章以个体运行引擎为基础,建立任务接收与运行流程、内部程序组织、能力与方法执行衔接、运行过程记录和闭环测试机制。程序目录、数据库和代码均作为拟定工程设计示例,后续实际实施时需要结合确定的项目目录、数据库结构和设备运行接口进行调整。

    1. 个体任务接收与运行流程

    个体任务接收是自主运行程序的入口。任务可以由智能控制后台下发,也可以来自个体本地任务队列、预先部署的运行计划、外部设备接口或者本地控制程序。在通信运行模式下,个体可以接收后台发送的任务信息、任务调整信息和运行约束更新信息;在无通信运行模式下,个体可以从本地任务队列和已部署的运行计划中获取任务。两种模式的任务来源不同,但进入个体运行引擎之后,应当使用统一的任务处理流程。

    工程实现首先需要解决任务数据的统一问题。不同来源的任务不能直接以各自的原始格式进入能力调用程序,否则运行引擎将需要针对不同任务来源编写大量独立处理逻辑,导致任务入口与内部执行程序产生不必要的耦合。因此,应当在任务接收阶段建立统一的任务数据结构,将外部任务转换为个体运行引擎能够识别的任务实例。

    任务定义与任务实例需要区分。任务定义描述任务的目标、对象、能力需求、运行条件和执行约束,是任务本身的结构化描述。任务实例则代表某个个体在特定时间接收到的一次具体任务,包含任务定义引用、任务来源、接收时间、当前状态、运行上下文和执行记录。同一个任务定义可以在不同时间形成多个任务实例,也可以由不同个体分别执行,但每个任务实例都必须具有独立的运行标识。

    例如,智能控制后台需要组织多个仓库机器人完成物料搬运任务。后台根据仓库整体任务、机器人职责和已赋予的知识能力,为不同个体形成具体任务。任务内容可以包含目标物料、目标区域、搬运数量、路线条件、执行优先级和安全约束。个体接收到任务后,不需要重新规划整个仓库的任务组织体系,而是根据本地已经赋予的知识能力、对象信息和执行规则判断任务是否能够进入运行流程。

    任务实例的数据结构可以设计为:

    {
        "task_instance_id": "task_instance_000128",
        "task_definition_id": "task_transport_001",
        "individual_id": "individual_001",
        "task_source": "central_control",
        "task_type": "transport",
        "target_object": "material_0001",
        "target_location": "area_B",
        "required_capabilities": [
            "material_recognition",
            "route_navigation",
            "material_transport"
        ],
        "assignment_version": "assignment_v003",
        "execution_constraints": {
            "safety_check": true,
            "operation_scope": "warehouse_area_A_B"
        },
        "priority": 5,
        "status": "received",
        "created_at": "2026-11-15 10:30:00"
    }

    这里的任务实例引用了个体的赋值版本。这样设计的目的是使任务运行过程能够明确对应到具体的知识能力版本。当个体后续获得新的能力赋值时,已经开始运行的任务不能在没有明确规则的情况下随意切换到新版本,否则同一任务前后可能使用不同的结构定义、方法和执行规则,影响运行结果的一致性。

    任务接收后,程序首先检查任务数据的完整性、任务标识是否重复、任务是否属于当前个体、任务状态是否允许接收,以及任务所引用的赋值版本是否能够在本地找到。对于需要使用后台赋值版本的任务,如果本地版本不一致,不能仅凭任务标识相同就直接运行,而应当按照任务版本策略进行处理。

    任务接收程序可以组织在以下目录中:

    IndividualRuntime/
    └── runtime/
        ├── task/
        │   ├── TaskReceiver.php                 # 接收来自后台、外部接口和本地队列的任务
        │   ├── TaskNormalizer.php               # 将不同来源的任务转换为统一任务结构
        │   ├── TaskDefinitionReader.php          # 读取任务定义及其结构化要求
        │   ├── TaskInstanceBuilder.php           # 根据任务定义生成独立任务实例
        │   ├── TaskIdentityChecker.php           # 检查任务标识和目标个体身份
        │   ├── TaskDuplicateChecker.php          # 检查重复接收和重复任务实例
        │   ├── TaskValidator.php                 # 检查任务数据完整性与基本有效性
        │   └── TaskReceiverResult.php            # 组织任务接收处理结果
        ├── admission/
        │   ├── TaskAdmissionManager.php          # 组织任务进入自主运行流程
        │   ├── AssignmentVersionResolver.php     # 确认任务使用的个体赋值版本
        │   ├── TaskReadinessChecker.php          # 调用自主运行判断结果
        │   └── TaskAdmissionResult.php           # 保存任务接收与准入结果
        └── queue/
            ├── LocalTaskQueue.php                # 管理个体本地任务队列
            ├── TaskQueueReader.php               # 读取待处理任务
            ├── TaskQueueWriter.php               # 写入新接收的任务
            └── TaskQueueManager.php              # 管理任务入队、出队和恢复

    TaskReceiver.php是任务进入个体运行环境的入口程序。它不负责直接调用设备,也不负责完成任务本身,而是将不同来源的任务交给TaskNormalizer.php进行统一处理。经过标准化的任务由TaskValidator.php检查,之后由TaskInstanceBuilder.php生成任务实例。任务实例形成后,再交给TaskAdmissionManager.php,调用第二十九章建立的自主运行判断机制。

    任务准入不能简单地以任务接收成功作为运行成功。接收成功只表示个体已经获得并保存任务信息;任务准入成功表示任务经过相关检查,具备进入自主运行流程的条件。只有任务准入通过,才能进入运行初始化和程序调度阶段。

    任务准入程序可以设计为:

    <?php
    
    class TaskAdmissionManager
    {
        private $validator;
        private $judgment;
        private $queue;
    
        public function __construct(
            $validator,
            $judgment,
            $queue
        ) {
            $this->validator = $validator;
            $this->judgment = $judgment;
            $this->queue = $queue;
        }
    
        public function admit($task)
        {
            $valid = $this->validator->validate($task);
    
            if (!$valid['success']) {
                return array(
                    'success' => false,
                    'status' => 'rejected',
                    'reason' => $valid['reason']
                );
            }
    
            $judgment = $this->judgment->check($task);
    
            if (!$judgment['autonomous_ready']) {
                return array(
                    'success' => false,
                    'status' => 'waiting',
                    'judgment' => $judgment
                );
            }
    
            $queued = $this->queue->push($task);
    
            if (!$queued) {
                return array(
                    'success' => false,
                    'status' => 'queue_failed'
                );
            }
    
            return array(
                'success' => true,
                'status' => 'admitted',
                'task_instance_id' => $task['task_instance_id']
            );
        }
    }

    该程序体现了任务接收、有效性检查、自主运行判断和任务入队之间的调用关系。这里的judgment是对第二十九章自主运行判断程序的调用接口,实际工程中应当复用已经形成的判断结果或由统一判断服务重新执行检查,而不是在任务准入程序中重新编写一套相互独立的能力匹配规则。

    任务进入队列后,由运行调度程序决定何时开始处理。任务调度需要考虑个体当前运行状态、任务优先级、任务之间的依赖关系、并行条件以及资源占用情况。对于只能顺序执行的任务,调度程序应当等待当前任务释放相应资源;对于允许并行的任务,则必须明确并行范围,不能仅因为个体具有多个能力就认定多个任务可以同时运行。

    在工程上,任务队列需要支持任务等待、任务恢复、任务取消和任务重新调度。任务因运行条件暂时不满足而进入等待状态时,应当保留原有任务实例及其上下文,而不是删除后重新接收。任务恢复时需要重新检查关键运行条件,避免将任务接收时的判断结果长期视为有效。

    个体任务的整体运行流程可以形成如下关系:

    任务来源
       |
       v
    任务接收
       |
       v
    任务格式统一
       |
       v
    任务实例建立
       |
       v
    任务有效性检查
       |
       v
    自主运行判断
       |
       +---- 不满足运行条件 ----> 等待、调整或反馈
       |
       v
    任务进入本地队列
       |
       v
    运行调度
       |
       v
    运行上下文初始化
       |
       v
    内部处理程序执行
       |
       v
    知识能力调用
       |
       v
    方法执行衔接
       |
       v
    运行结果与状态更新
       |
       v
    任务继续、暂停、结束或异常处理

    这一流程中,任务来源可以是后台通信,也可以是本地任务计划。任务进入本地运行引擎之后,执行过程不应依赖持续通信。通信模式下可以将任务状态和运行结果同步到后台;无通信模式下则由个体本地保存任务、状态和结果,等待通信恢复后再按照同步规则处理。

    2. 个体内部处理程序的组织

    个体自主运行需要建立内部程序组织结构,使任务接收、运行判断、信息读取、结构匹配、能力调用、方法执行和结果处理形成相互衔接的程序体系。若将全部处理过程集中在一个任务执行文件中,程序会同时承担任务解析、对象识别、能力匹配、规则判断、方法调用、设备操作和结果记录等工作。随着任务类型增加,这种组织方式容易造成程序之间的依赖关系混乱,也不利于不同个体之间复用相同的运行机制。

    因此,个体内部处理程序应当以运行引擎为核心,将运行控制和具体业务能力分开组织。运行引擎负责运行流程、任务上下文、程序调度和状态转换;知识结构和能力组件负责根据任务需要提供相应的结构信息与处理能力;方法执行组件负责完成能力定义中涉及的具体操作;设备接口负责将需要作用于外部对象的操作转换为实际设备或软件接口调用。

    这种组织方式并不意味着每个个体都必须部署完全相同的全部程序。不同个体可以共享基本运行引擎的程序结构,但根据职责差异加载不同的知识结构、能力、方法和执行规则。对于只承担信息采集职责的个体,可以部署信息获取、对象识别和状态判断相关能力;对于承担物料搬运职责的机器人,则需要部署对象识别、路线处理、运动控制和安全约束相关能力。具体部署内容由智能控制后台根据任务需求和个体职责确定。

    个体内部处理程序可以采用以下目录组织:

    IndividualRuntime/
    ├── engine/
    │   ├── RuntimeKernel.php                   # 个体自主运行的核心控制程序
    │   ├── RuntimeScheduler.php                # 根据任务和资源条件组织程序调度
    │   ├── RuntimeDispatcher.php               # 将运行请求分发到对应处理程序
    │   ├── RuntimeContextManager.php            # 建立、读取和更新任务运行上下文
    │   ├── RuntimeStateManager.php              # 管理个体和任务运行状态
    │   └── RuntimeExceptionManager.php          # 组织运行异常识别与处理
    ├── task/
    │   ├── TaskReceiver.php                     # 任务接收入口
    │   ├── TaskProcessor.php                    # 任务实例的处理程序
    │   ├── TaskLifecycleManager.php             # 管理任务运行生命周期
    │   └── TaskResultBuilder.php                # 组织任务处理结果
    ├── information/
    │   ├── RuntimeInformationReader.php         # 读取当前任务所需的运行信息
    │   ├── ObjectInformationProcessor.php       # 处理外部对象信息
    │   └── ObjectStateUpdater.php               # 更新对象实例及其运行状态
    ├── structure/
    │   ├── StructureLoader.php                  # 加载已赋值的知识结构
    │   ├── StructureMatcher.php                 # 将实际对象信息与知识结构匹配
    │   └── StructureContextResolver.php         # 解析当前任务所需的结构上下文
    ├── capability/
    │   ├── CapabilityLoader.php                 # 加载个体已经获得的知识能力
    │   ├── CapabilityMatcher.php                # 根据任务要求匹配可用能力
    │   ├── CapabilityInvoker.php                # 组织知识能力调用
    │   └── CapabilityResultProcessor.php        # 处理能力调用结果
    ├── method/
    │   ├── MethodRegistry.php                   # 管理已部署的方法定义与实现映射
    │   ├── MethodResolver.php                   # 根据能力要求解析具体方法
    │   ├── MethodDispatcher.php                 # 调用对应方法实现
    │   └── MethodResultProcessor.php            # 处理方法执行结果
    ├── rules/
    │   ├── ExecutionRuleLoader.php              # 加载个体已赋值的执行规则
    │   ├── ExecutionRuleChecker.php             # 检查方法执行前的规则条件
    │   └── ExecutionBoundaryChecker.php         # 检查执行范围与权限边界
    ├── device/
    │   ├── DeviceInterfaceManager.php           # 管理个体与外部设备接口的连接
    │   ├── SensorAdapter.php                    # 读取传感器信息
    │   └── ActuatorAdapter.php                  # 向执行机构提交受控操作
    └── result/
        ├── RuntimeResultCollector.php           # 收集运行过程和阶段结果
        ├── RuntimeRecordWriter.php              # 保存运行记录
        └── RuntimeFeedbackBuilder.php            # 形成可供后台处理的运行反馈

    这里的目录结构是对运行引擎及其内部处理程序的工程组织设计。实际项目可以根据程序规模合并部分文件,也可以将设备接口独立部署,但任务处理、能力调用、方法执行和运行记录之间的逻辑边界应当保持清楚。

    RuntimeKernel.php是整个个体运行过程的核心入口。它不直接包含所有具体任务的业务逻辑,而是按照运行阶段组织程序调用。任务接收完成后,运行内核建立任务上下文,读取当前个体的赋值信息,确认所需知识结构和能力是否已经加载,再将任务交给对应的处理程序。

    运行内核的调用关系可以设计为:

    RuntimeKernel
        |
        +---- RuntimeContextManager
        |         |
        |         +---- TaskContext
        |         +---- AssignmentContext
        |         +---- ObjectContext
        |
        +---- RuntimeScheduler
        |         |
        |         +---- TaskProcessor
        |         +---- RuntimeDispatcher
        |
        +---- StructureLoader
        |         |
        |         +---- StructureMatcher
        |
        +---- CapabilityLoader
        |         |
        |         +---- CapabilityMatcher
        |         +---- CapabilityInvoker
        |
        +---- ExecutionRuleLoader
        |         |
        |         +---- ExecutionRuleChecker
        |
        +---- MethodDispatcher
        |
        +---- RuntimeResultCollector
                  |
                  +---- RuntimeRecordWriter
                  +---- RuntimeFeedbackBuilder

    运行内核在调用各个程序时,需要传递统一的运行上下文。运行上下文不是简单的任务参数集合,而是当前任务运行过程中各种对象、结构、能力、方法、赋值版本和状态信息的关联载体。

    例如,任务上下文可以设计为:

    {
        "context_id": "context_000128",
        "individual_id": "individual_001",
        "task_instance_id": "task_instance_000128",
        "assignment_version": "assignment_v003",
        "structure_versions": {
            "material_structure": "v002",
            "route_structure": "v004"
        },
        "current_object": "material_0001",
        "current_capability": "material_transport",
        "current_method": null,
        "runtime_stage": "capability_matching",
        "runtime_state": "running",
        "started_at": "2026-11-15 10:35:00"
    }

    上下文中保存的赋值版本和结构版本用于确定当前运行过程所依据的知识内容。runtime_stage表示任务正在执行的程序阶段,runtime_state表示任务当前运行状态。两者不能混为一谈。例如,任务可以处于running状态,而当前阶段为object_recognition;也可以处于waiting状态,而当前阶段仍然是method_execution。

    运行上下文管理程序需要支持创建、读取、更新、保存和恢复。任务在正常执行过程中,运行上下文随处理阶段不断变化。当任务暂停或者个体发生异常时,系统需要保存最后一个有效检查点。恢复运行时,程序根据上下文确定已经完成的阶段,并判断哪些阶段需要重新执行。

    对于机器人、无人机和工业设备,运行上下文还需要关联设备对象、传感器采样时间、设备运行模式、当前执行机构状态和操作记录。对于软件个体,则可能关联业务对象、数据记录、程序进程和外部服务接口。虽然具体运行对象不同,但都可以通过统一的上下文管理机制保持任务与实际运行对象之间的关系。

    内部程序还需要处理运行程序和知识能力之间的依赖关系。运行引擎是个体执行任务的基础程序,不等于知识能力本身。知识能力是通过已经形成并赋予个体的知识结构与方法组织而获得的处理能力。运行引擎负责调用这些能力,但不能因为某个方法程序存在,就自动认为个体已经具备相应的完整知识能力。能力是否可用,仍然需要检查能力定义、结构依赖、方法映射、执行规则和赋值版本。

    这种程序组织方式使个体可以在不改变运行引擎主体结构的情况下增加或替换已赋值能力。后台形成新能力并完成验证后,可以按照赋值和部署机制将其交付给指定个体。个体加载新能力后,运行引擎通过能力注册和映射关系识别该能力,不需要针对每一种新增能力重新编写整个任务运行流程。

    3. 自主运行与方法执行的衔接

    自主运行程序最终需要进入具体方法执行环节。前面的任务接收、结构匹配、能力识别和运行判断,都是为了确定当前任务是否具备执行条件,以及应该调用哪些已经赋予个体的知识能力。方法执行则将能力所要求的具体操作转化为程序调用,进一步作用于数据对象、软件业务对象或者实际设备。

    这里必须明确能力与方法的区别。知识能力是围绕某一问题或任务形成的结构化处理能力,包含所依赖的知识结构、适用条件、相关方法及其组合关系。方法是完成具体操作的程序单元,例如读取、比较、计算、判断、匹配、排序、验证或者控制操作。一个能力可以由多个方法组成,也可以根据任务条件选择不同的方法组合。一个方法也可能被多个能力共同引用,但方法被调用并不意味着相关能力已经完整执行。

    例如,机器人执行物料搬运任务时,不能将“搬运”直接等同于某一个运动控制方法。搬运能力可能涉及物料对象识别、物料状态判断、目标位置匹配、路线条件判断、运动路径处理、抓取条件验证和执行机构控制等多个处理环节。运行引擎首先根据任务和实际对象信息匹配搬运能力,再由能力定义确定相关方法及其执行关系,最后才进入方法分发和设备接口调用。

    工程实现中,应当建立能力定义与方法定义之间的关联。能力定义可以采用如下结构:

    {
        "capability_id": "material_transport",
        "capability_name": "物料搬运能力",
        "required_structures": [
            "material_structure",
            "route_structure",
            "robot_structure"
        ],
        "methods": [
            {
                "method_id": "recognize_material",
                "sequence": 1,
                "required": true
            },
            {
                "method_id": "check_material_state",
                "sequence": 2,
                "required": true
            },
            {
                "method_id": "match_target_location",
                "sequence": 3,
                "required": true
            },
            {
                "method_id": "check_transport_constraints",
                "sequence": 4,
                "required": true
            },
            {
                "method_id": "execute_transport",
                "sequence": 5,
                "required": true
            }
        ],
        "completion_condition": {
            "target_location_reached": true,
            "material_state_verified": true
        }
    }

    这个定义描述了搬运能力所依赖的结构和方法组织关系。方法执行顺序可以由能力定义确定,也可以根据对象状态和条件判断形成分支。工程实现时不能把所有能力都设计成固定的线性方法列表,因为有些能力需要根据条件选择不同处理路径。

    因此,方法组织需要同时支持顺序调用、条件调用、结果判断和异常分支。方法之间的关系可以采用执行步骤定义:

    {
        "method_flow_id": "flow_transport_001",
        "capability_id": "material_transport",
        "steps": [
            {
                "step_id": "step_01",
                "method_id": "recognize_material",
                "next": "step_02"
            },
            {
                "step_id": "step_02",
                "method_id": "check_material_state",
                "next": "step_03"
            },
            {
                "step_id": "step_03",
                "method_id": "match_target_location",
                "next": "step_04"
            },
            {
                "step_id": "step_04",
                "method_id": "check_transport_constraints",
                "next": "step_05"
            },
            {
                "step_id": "step_05",
                "method_id": "execute_transport",
                "next": "complete"
            }
        ]
    }

    在真实工程中,next还可以引用条件分支标识。例如,目标位置不可用时转入重新匹配流程;物料状态不符合搬运条件时转入等待或异常处理;安全约束不满足时禁止执行。分支条件必须来自已经赋予个体的知识能力和执行规则,不能由方法执行程序任意改变。

    方法调用需要统一接口。不同方法可能对应数据处理、结构判断、外部软件调用或设备控制,如果每种方法都使用不同的参数和返回格式,能力调用程序就无法统一处理执行结果。因此,可以建立方法调用接口:

    <?php
    
    interface RuntimeMethodInterface
    {
        public function execute($context, $parameters);
    
        public function getMethodId();
    }

    具体方法实现需要遵守接口约定。例如,一个对象状态判断方法可以实现为:

    <?php
    
    class CheckMaterialStateMethod
        implements RuntimeMethodInterface
    {
        public function getMethodId()
        {
            return 'check_material_state';
        }
    
        public function execute($context, $parameters)
        {
            if (
                !isset($parameters['material_state']) ||
                !isset($parameters['allowed_states'])
            ) {
                return array(
                    'success' => false,
                    'status' => 'invalid_input'
                );
            }
    
            $allowed = in_array(
                $parameters['material_state'],
                $parameters['allowed_states'],
                true
            );
    
            return array(
                'success' => true,
                'status' => $allowed ? 'matched' : 'not_matched',
                'result' => $allowed
            );
        }
    }

    该方法只负责检查物料状态是否符合给定条件,不负责决定整个搬运任务是否完成,也不负责直接控制机器人。它的执行结果需要返回给能力调用程序,由能力调用程序结合当前能力定义、其他方法结果和执行约束形成后续处理路径。

    方法注册程序负责将方法标识与具体程序实现建立映射关系。例如:

    <?php
    
    class MethodRegistry
    {
        private $methods = array();
    
        public function register($method)
        {
            $id = $method->getMethodId();
    
            if (isset($this->methods[$id])) {
                return false;
            }
    
            $this->methods[$id] = $method;
    
            return true;
        }
    
        public function get($methodId)
        {
            if (!isset($this->methods[$methodId])) {
                return null;
            }
    
            return $this->methods[$methodId];
        }
    }

    MethodRegistry负责维护方法注册信息,MethodDispatcher负责根据能力定义和当前运行上下文调用方法。方法注册时还需要检查方法所属赋值包、版本、接口类型和依赖关系,避免将未赋予个体的方法作为可用方法调用。

    方法分发程序可以设计为:

    <?php
    
    class MethodDispatcher
    {
        private $registry;
        private $ruleChecker;
    
        public function __construct(
            $registry,
            $ruleChecker
        ) {
            $this->registry = $registry;
            $this->ruleChecker = $ruleChecker;
        }
    
        public function dispatch(
            $methodId,
            $context,
            $parameters
        ) {
            $ruleResult = $this->ruleChecker->check(
                $methodId,
                $context,
                $parameters
            );
    
            if (!$ruleResult['allowed']) {
                return array(
                    'success' => false,
                    'status' => 'blocked',
                    'reason' => $ruleResult['reason']
                );
            }
    
            $method = $this->registry->get($methodId);
    
            if ($method === null) {
                return array(
                    'success' => false,
                    'status' => 'method_not_found'
                );
            }
    
            return $method->execute(
                $context,
                $parameters
            );
        }
    }

    这里的规则检查发生在具体方法执行之前。对于纯数据处理方法,规则可能主要涉及数据范围、结构依赖和操作权限;对于设备控制方法,则还需要检查设备状态、执行范围、操作许可、安全联锁和停止条件。规则检查失败时,程序应当阻止方法调用,而不是将其作为普通方法失败后继续执行。

    能力调用程序负责把多个方法组织为完整的能力处理过程。它根据能力定义读取方法清单,检查方法是否存在、依赖结构是否有效,再按照能力定义中的步骤逐个调用。每个方法的执行结果都应当返回给能力调用程序,由其决定下一步方法、条件分支或终止路径。

    例如:

    <?php
    
    class CapabilityInvoker
    {
        private $dispatcher;
    
        public function __construct($dispatcher)
        {
            $this->dispatcher = $dispatcher;
        }
    
        public function invoke(
            $capability,
            $context,
            $methodParameters
        ) {
            $results = array();
    
            foreach ($capability['methods'] as $item) {
                $methodId = $item['method_id'];
    
                $parameters = isset(
                    $methodParameters[$methodId]
                ) ? $methodParameters[$methodId] : array();
    
                $result = $this->dispatcher->dispatch(
                    $methodId,
                    $context,
                    $parameters
                );
    
                $results[$methodId] = $result;
    
                if (
                    !isset($result['success']) ||
                    !$result['success']
                ) {
                    return array(
                        'success' => false,
                        'status' => 'capability_interrupted',
                        'failed_method' => $methodId,
                        'method_results' => $results
                    );
                }
            }
    
            return array(
                'success' => true,
                'status' => 'capability_completed',
                'method_results' => $results
            );
        }
    }

    这段代码展示的是基本的顺序调用模式。实际工程中的能力调用程序还需要根据方法流程定义处理条件分支、可选方法、重复判断、超时、暂停和恢复等情况。对于具有实际设备操作的能力,方法执行还应区分操作请求提交、设备执行确认和执行结果验证,不能将接口返回成功直接认定为设备已经完成动作。

    例如,机器人发送移动命令后,控制接口返回“命令已接收”,只说明命令进入设备控制程序,不表示机器人已经到达目标位置。个体还需要读取位置状态、运动状态和安全状态,确认实际执行结果是否满足任务要求。对于可能产生重复动作的控制方法,应当采用操作标识、执行阶段记录和设备状态确认机制,防止任务恢复时重复发送已经执行的动作。

    方法执行完成后,能力调用程序将结果交给CapabilityResultProcessor.php。该程序需要区分方法执行成功、能力处理完成和任务目标实现三个层次。某个方法成功执行,不代表能力全部完成;能力处理完成,也不一定代表任务目标已经实现。只有结合任务目标、结果条件和实际对象状态进行验证,才能形成任务层面的完成判断。

    自主运行与方法执行之间的衔接关系最终形成:

    任务实例
       |
       v
    运行上下文建立
       |
       v
    对象信息读取
       |
       v
    知识结构匹配
       |
       v
    知识能力识别
       |
       v
    能力适用条件判断
       |
       v
    能力定义读取
       |
       v
    方法流程解析
       |
       v
    执行规则检查
       |
       v
    方法分发与调用
       |
       v
    方法结果处理
       |
       v
    能力结果形成
       |
       v
    任务目标验证
       |
       +---- 未完成 ----> 继续处理、等待或异常处理
       |
       v
    任务结果形成

    该机制将自主运行判断与具体方法执行连接起来,使个体能够根据任务要求使用已经赋予的知识能力完成处理,而不是将自主运行简化为直接调用某个预设动作程序。

    4. 运行过程记录与状态更新

    个体自主运行过程中会持续产生任务状态、对象状态、能力调用结果、方法执行结果、设备运行信息和异常信息。如果这些信息只保存在内存中,一旦程序中断、设备断电或运行进程异常退出,个体就无法准确恢复任务进度,也无法判断哪些方法已经执行、哪些操作尚未完成。因此,必须建立运行过程记录和状态更新机制,使每个重要运行阶段都能够被识别、保存和追踪。

    运行过程记录不能只记录任务开始和任务结束两个时间点。对于包含多个能力和方法的任务,应当记录任务接收、任务准入、运行初始化、结构加载、对象识别、能力匹配、方法调用、结果处理和任务结束等关键阶段。对于需要操作外部设备的任务,还应当记录控制请求、设备确认、实际状态变化和结果验证信息。

    运行记录需要区分任务记录、运行阶段记录、方法执行记录、异常记录和状态变化记录。任务记录用于描述一个完整任务实例;运行阶段记录用于描述任务在不同处理阶段的进度;方法执行记录用于追踪具体方法的调用参数、执行时间和返回结果;异常记录用于保存运行中出现的问题;状态变化记录用于保存个体和任务状态的变化过程。

    可以在数据库中设计以下数据表。

    individual_tasks用于保存任务实例的基本信息:

    CREATE TABLE individual_tasks (
        id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
        task_instance_id VARCHAR(100) NOT NULL,
        task_definition_id VARCHAR(100) NOT NULL,
        individual_id VARCHAR(100) NOT NULL,
        assignment_version VARCHAR(100) NOT NULL,
        task_source VARCHAR(50) NOT NULL,
        task_type VARCHAR(100) NOT NULL,
        task_status VARCHAR(50) NOT NULL,
        priority INT DEFAULT 0,
        context_id VARCHAR(100) DEFAULT NULL,
        created_at DATETIME NOT NULL,
        started_at DATETIME DEFAULT NULL,
        completed_at DATETIME DEFAULT NULL,
        updated_at DATETIME NOT NULL,
        UNIQUE KEY uk_task_instance (task_instance_id),
        KEY idx_individual_status (
            individual_id,
            task_status
        )
    );

    该表保存任务实例与个体、赋值版本之间的基本关联。task_status记录任务当前状态,context_id关联运行上下文。对于同一个任务定义,不同个体或者不同时间形成的任务实例都应当拥有不同的task_instance_id。

    individual_runtime_records用于保存任务运行阶段记录:

    CREATE TABLE individual_runtime_records (
        id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
        runtime_record_id VARCHAR(100) NOT NULL,
        task_instance_id VARCHAR(100) NOT NULL,
        individual_id VARCHAR(100) NOT NULL,
        runtime_stage VARCHAR(100) NOT NULL,
        runtime_status VARCHAR(50) NOT NULL,
        input_data JSON DEFAULT NULL,
        output_data JSON DEFAULT NULL,
        started_at DATETIME DEFAULT NULL,
        finished_at DATETIME DEFAULT NULL,
        created_at DATETIME NOT NULL,
        UNIQUE KEY uk_runtime_record (runtime_record_id),
        KEY idx_task_stage (
            task_instance_id,
            runtime_stage
        )
    );

    该表用于保存任务各个运行阶段的输入、输出和执行状态。数据库版本如果不支持原生JSON字段,可以将相关字段改为LONGTEXT,由程序负责校验JSON内容。

    individual_method_records用于保存方法调用记录:

    CREATE TABLE individual_method_records (
        id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
        method_record_id VARCHAR(100) NOT NULL,
        task_instance_id VARCHAR(100) NOT NULL,
        capability_id VARCHAR(100) NOT NULL,
        method_id VARCHAR(100) NOT NULL,
        method_version VARCHAR(100) DEFAULT NULL,
        execution_status VARCHAR(50) NOT NULL,
        input_data JSON DEFAULT NULL,
        output_data JSON DEFAULT NULL,
        operation_id VARCHAR(100) DEFAULT NULL,
        started_at DATETIME DEFAULT NULL,
        finished_at DATETIME DEFAULT NULL,
        created_at DATETIME NOT NULL,
        UNIQUE KEY uk_method_record (method_record_id),
        KEY idx_task_method (
            task_instance_id,
            method_id
        )
    );

    这里增加operation_id,主要用于需要与外部设备或业务系统交互的方法。操作标识可以帮助个体识别某一次具体操作请求,避免任务恢复或者接口重试时产生重复执行。

    individual_state_records用于保存个体状态变化:

    CREATE TABLE individual_state_records (
        id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
        individual_id VARCHAR(100) NOT NULL,
        task_instance_id VARCHAR(100) DEFAULT NULL,
        previous_state VARCHAR(50) DEFAULT NULL,
        current_state VARCHAR(50) NOT NULL,
        change_reason VARCHAR(255) DEFAULT NULL,
        state_data JSON DEFAULT NULL,
        changed_at DATETIME NOT NULL,
        KEY idx_individual_time (
            individual_id,
            changed_at
        )
    );

    individual_runtime_exceptions用于保存运行异常:

    CREATE TABLE individual_runtime_exceptions (
        id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
        exception_id VARCHAR(100) NOT NULL,
        individual_id VARCHAR(100) NOT NULL,
        task_instance_id VARCHAR(100) DEFAULT NULL,
        runtime_stage VARCHAR(100) DEFAULT NULL,
        exception_type VARCHAR(100) NOT NULL,
        exception_level VARCHAR(50) NOT NULL,
        exception_message TEXT,
        recovery_status VARCHAR(50) DEFAULT NULL,
        exception_data JSON DEFAULT NULL,
        created_at DATETIME NOT NULL,
        KEY idx_task_exception (
            task_instance_id,
            exception_type
        )
    );

    这些表之间通过individual_id、task_instance_id、runtime_record_id和method_record_id形成关联。一个任务实例可以对应多个运行阶段记录、多个方法调用记录和多个异常记录;一个个体可以对应多个任务实例和多个状态变化记录。通过这些关联,可以追溯某个个体在特定赋值版本下执行某项任务的完整过程。

    运行过程记录程序可以组织为:

    IndividualRuntime/
    └── recording/
        ├── RuntimeRecordManager.php          # 统一组织运行过程记录
        ├── TaskRecordWriter.php              # 保存任务实例记录
        ├── StageRecordWriter.php             # 保存运行阶段记录
        ├── MethodRecordWriter.php             # 保存方法调用记录
        ├── StateRecordWriter.php              # 保存个体和任务状态变化
        ├── ExceptionRecordWriter.php          # 保存运行异常
        ├── RuntimeCheckpointManager.php       # 保存运行检查点
        ├── RuntimeRecoveryManager.php         # 根据检查点恢复任务
        └── RuntimeRecordRepository.php        # 提供运行记录的数据访问

    运行记录管理程序应当与具体方法实现分离。方法程序执行时向运行记录管理程序提交开始信息和结果信息,运行记录管理程序负责统一保存。这样既能保证不同方法使用相同的记录规则,也能避免每个方法都自行编写数据库操作逻辑。

    状态更新同样需要统一管理。个体运行状态与任务运行状态是两个不同层次。个体运行状态描述当前个体整体运行情况,例如ready、running、waiting、suspended、maintenance和error。任务状态则描述具体任务实例的处理进度,例如received、admitted、queued、initializing、running、waiting、suspended、completed、failed和cancelled。

    一个个体可能在整体状态为running时执行一个任务,也可能在整体状态为running时等待某个任务的外部条件。多个任务并行运行时,个体状态不能简单地等同于其中某一个任务的状态。因此,工程中需要分别维护个体状态和任务状态,并通过状态管理程序确定二者之间的关联。

    任务状态转换可以设计为:

    received
       |
       v
    admitted
       |
       v
    queued
       |
       v
    initializing
       |
       v
    running
       |
       +---- waiting
       |        |
       |        v
       |      running
       |
       +---- suspended
       |        |
       |        v
       |      running
       |
       +---- failed
       |
       +---- cancelled
       |
       v
    completed

    状态转换必须具有明确的合法条件。例如,处于received状态的任务不能直接变为completed;处于running状态的任务可以根据实际条件转为waiting或suspended;处于completed状态的任务属于已完成的终态,不能在没有重新建立任务实例或明确重开机制的情况下直接恢复执行。

    状态管理程序可以采用以下方式实现:

    <?php
    
    class TaskStateManager
    {
        private $allowedTransitions = array(
            'received' => array(
                'admitted',
                'rejected'
            ),
            'admitted' => array(
                'queued',
                'waiting'
            ),
            'queued' => array(
                'initializing',
                'cancelled'
            ),
            'initializing' => array(
                'running',
                'waiting',
                'failed'
            ),
            'running' => array(
                'waiting',
                'suspended',
                'completed',
                'failed'
            ),
            'waiting' => array(
                'running',
                'cancelled',
                'failed'
            ),
            'suspended' => array(
                'running',
                'cancelled',
                'failed'
            )
        );
    
        public function canChange($oldState, $newState)
        {
            if (!isset(
                $this->allowedTransitions[$oldState]
            )) {
                return false;
            }
    
            return in_array(
                $newState,
                $this->allowedTransitions[$oldState],
                true
            );
        }
    }

    这段代码只展示状态转换规则的基本实现。实际项目中,状态变化还需要结合当前任务标识、状态版本、运行锁和数据库事务进行检查,避免多个运行进程同时更新同一个任务时出现状态覆盖。

    运行检查点是运行记录机制中的重要部分。对于一个持续时间较长、包含多个外部操作的任务,不能只在任务完成后保存结果。每完成一个重要阶段,个体都应当保存当前任务上下文、已完成方法、待执行方法、对象状态摘要和当前赋值版本。发生异常后,运行恢复程序根据检查点确定恢复位置。

    但检查点恢复并不意味着无条件重复执行上次未确认完成的方法。对于数据查询、结构匹配等可重复操作,可以根据方法特性重新执行;对于机械抓取、设备启动、物料移动等可能产生实际动作的方法,必须先确认外部对象和设备的实际状态,再决定是否继续执行。否则,程序恢复可能造成重复动作或者操作冲突。

    运行反馈还需要区分个体本地处理与后台知识能力调整。个体可以记录新对象信息、运行异常、能力不足、执行失败和任务完成情况,并形成结构化反馈。智能控制后台收到反馈后,才根据整体需求和知识结构分析确定是否需要增加、调整或替换知识能力。个体不能仅凭某次运行失败就直接修改自身知识定义,不能在没有后台验证和赋值的情况下自行扩大知识能力范围。

    在通信模式下,运行记录可以按照设定的同步策略上传后台;在无通信模式下,运行记录保存在本地存储中。通信恢复后,需要根据任务标识、记录标识、赋值版本和时间顺序进行同步,避免重复提交或者覆盖后台已有记录。对于重要设备操作记录,应当保证本地保存优先于网络同步,不能因通信失败而丢失实际执行过程。

    5. 个体自主运行闭环测试

    个体自主运行程序不能只通过检查PHP文件是否存在、程序是否能够启动或者接口是否返回成功来确认其运行正确。工程验证必须覆盖任务接收、任务准入、上下文建立、知识能力调用、方法执行、状态更新、运行记录和任务结果确认等完整环节。

    本节所设计的闭环测试以个体自主运行引擎为验证对象,重点检查不同运行阶段之间的数据关系和程序调用关系是否正确。这里的测试案例属于拟定工程验证设计,并不表示相关程序已经在实际机器人、无人机或工业设备上完成部署和测试。

    首先需要建立测试对象和测试数据。可以使用一个模拟仓库机器人个体作为测试对象,赋予其物料识别、状态判断、目标位置匹配和物料搬运相关能力。测试环境中设置物料对象、目标区域、路线结构、机器人状态和执行约束,使任务运行过程能够覆盖从信息获取到结果验证的完整链路。

    测试个体可以采用以下基础数据:

    {
        "individual_id": "individual_test_001",
        "individual_type": "warehouse_robot",
        "runtime_state": "ready",
        "assignment_version": "assignment_test_v001",
        "assigned_capabilities": [
            "material_recognition",
            "material_state_check",
            "target_location_match",
            "material_transport"
        ],
        "runtime_mode": "local_autonomous",
        "operation_scope": [
            "warehouse_area_A",
            "warehouse_area_B"
        ]
    }

    任务测试数据可以设计为:

    {
        "task_instance_id": "task_test_000001",
        "individual_id": "individual_test_001",
        "task_type": "material_transport",
        "target_object": "material_test_001",
        "target_location": "warehouse_area_B",
        "required_capabilities": [
            "material_recognition",
            "material_state_check",
            "target_location_match",
            "material_transport"
        ],
        "execution_constraints": {
            "operation_scope": "warehouse_area_A_B",
            "safety_check": true
        },
        "status": "received"
    }

    在测试开始之前,需要确认个体赋值版本、知识结构版本、能力定义、方法实现和执行规则之间的引用关系一致。测试数据必须与实际加载的数据保持对应,不能在任务定义中引用一个不存在的能力,再通过测试程序直接绕过能力匹配。

    任务接收测试首先检查不同来源的任务能否被转换为统一的任务实例。测试时可以分别模拟后台任务输入、本地任务队列输入和外部接口输入,检查任务标识、个体标识、任务目标、能力要求和赋值版本是否被正确保存。对于格式错误、目标个体不匹配、任务标识重复和赋值版本不存在等情况,应当检查程序是否拒绝接收或者进入明确的等待处理状态。

    任务准入测试需要覆盖正常条件和异常条件。正常情况下,个体已获得任务所需的知识能力,运行环境正常,当前状态允许接收任务,执行约束满足要求,任务应当进入本地运行队列。若缺少某项能力,程序应当形成能力缺口结果,不能直接调用一个没有赋值的能力。如果运行资源暂时不足,任务应当等待。如果执行约束不允许当前操作,任务应当被阻止,而不能将其当作普通运行失败处理。

    内部程序组织测试需要检查运行内核能否正确调用上下文管理程序、任务处理程序、结构加载程序、能力调用程序和结果记录程序。测试重点不是检查某个文件能否单独运行,而是验证程序之间的数据传递和依赖关系。例如,能力调用程序必须获得当前任务的运行上下文;方法分发程序必须能够根据方法标识找到正确实现;结果处理程序必须能够区分方法执行成功与能力执行完成。

    能力与方法衔接测试需要验证能力定义中的方法映射是否正确。对于每项测试能力,都应当检查所需结构是否存在、方法是否已经部署、方法版本是否匹配、方法调用参数是否完整,以及方法执行结果是否能够返回能力调用程序。对于条件分支,还需要检查不同条件下是否进入正确的后续方法。

    在仓库机器人案例中,可以设置物料状态正常、物料状态异常、目标区域不可用、路线条件不满足和设备状态异常等不同情况。物料状态正常且目标位置有效时,能力调用程序按照定义的方法流程继续处理;物料状态异常时,程序应当停止后续搬运操作;目标位置不可用时,可以根据已经赋予的能力和规则进入目标位置重新匹配流程;设备状态异常时,应当停止相关设备操作并保存异常记录。

    对于设备控制方法,闭环测试必须进一步检查实际状态确认。测试环境中可以使用模拟设备接口验证命令提交、命令接收、执行状态读取和结果确认之间的关系。模拟测试通过只能说明程序接口和处理流程满足相应测试条件,不能代替真实设备运行验证。真实设备测试还需要在受控环境下检查设备响应、操作范围、安全联锁、停止机制和异常恢复。

    运行记录测试需要检查任务记录、阶段记录、方法记录、状态变化记录和异常记录是否形成完整关联。每次方法调用都应当能够追溯到具体任务实例和能力;每次状态变化都应当保存变化前状态、变化后状态及其原因;发生异常时,应当能够确定异常出现的运行阶段以及对应的方法或对象。

    运行恢复测试则需要在不同运行阶段模拟程序中断。任务尚未开始方法执行时发生中断,恢复程序应当能够根据任务状态和上下文重新进入运行流程;某个普通数据处理方法执行后发生中断,程序可以根据方法执行记录和幂等规则判断是否需要重新执行;设备控制命令已经提交但尚未确认执行结果时,程序必须先读取设备实际状态,再决定是否继续。不能简单地从上一个程序行重新开始执行。

    为了统一测试结果,可以建立自主运行测试记录表:

    CREATE TABLE individual_runtime_tests (
        id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
        test_case_id VARCHAR(100) NOT NULL,
        individual_id VARCHAR(100) NOT NULL,
        task_instance_id VARCHAR(100) DEFAULT NULL,
        test_stage VARCHAR(100) NOT NULL,
        expected_result TEXT,
        actual_result TEXT,
        test_status VARCHAR(30) NOT NULL,
        error_message TEXT,
        tested_at DATETIME NOT NULL,
        UNIQUE KEY uk_test_case (test_case_id),
        KEY idx_individual_test (
            individual_id,
            test_stage
        )
    );

    测试程序可以按照任务接收、任务准入、上下文建立、能力调用、方法执行、状态更新、结果验证和运行恢复等阶段组织测试案例。每个测试案例都应当具有明确的输入条件、预期结果和实际结果,不能只保存一个笼统的成功或失败标识。

    闭环测试的总体关系如下:

    测试个体建立
          |
          v
    知识能力赋值检查
          |
          v
    测试任务生成
          |
          v
    任务接收验证
          |
          v
    自主运行判断验证
          |
          v
    内部程序调用验证
          |
          v
    知识能力调用验证
          |
          v
    方法执行验证
          |
          v
    运行状态更新验证
          |
          v
    运行记录完整性验证
          |
          v
    任务结果确认
          |
          v
    运行中断与恢复测试
          |
          v
    通信与无通信模式测试
          |
          v
    形成闭环测试结果

    无通信运行测试需要在隔离通信的条件下进行。测试前,个体应当已经获得完成测试任务所需的知识结构、能力、方法、执行规则和本地任务信息。通信断开后,个体应当能够从本地任务入口接收或恢复任务,使用本地赋值内容完成允许范围内的自主处理,并保存运行状态和结果。通信恢复后,再检查本地记录是否能够按照同步规则提交后台。

    无通信测试不能理解为取消所有安全约束,也不能理解为个体可以不受后台赋值边界限制。通信中断时,个体仍然只能在本地已经获得的知识能力、方法、权限和执行规则范围内运行。遇到超出本地能力范围的任务,应当等待、停止或进入预先定义的安全处理路径,而不是自行扩展能力。

    对于多个个体同时执行任务的情况,还需要验证个体之间的任务边界和资源边界。例如,两个机器人不能因为分别接收到搬运任务,就同时进入同一条受限通道;不同个体也不能在没有明确授权和协调规则的情况下同时操作同一个设备对象。此类多智能个体协同控制的完整工程实现将在后续章节展开,本章只验证单一个体在既定职责和运行约束内的自主运行闭环。

    测试完成后,需要根据测试记录形成工程验收依据。验收不能只以程序启动成功为标准,而应当检查任务是否能够正确接收,任务准入是否准确,运行上下文是否完整,知识能力是否能够正确调用,方法执行是否遵循赋值规则,状态变化是否符合转换条件,运行记录是否可以追溯,以及异常发生后是否能够按照既定规则暂停、恢复或终止。

    当上述测试环节均符合预期时,可以确认当前测试范围内的个体自主运行程序具备进入下一阶段集成验证的条件。对于尚未进行真实设备测试的控制方法,只能确认模拟接口和程序流程通过相应验证,不能据此认定实体设备已经具备可靠运行能力。

    通过本章工程设计,个体自主运行程序形成了从任务接收到任务结果确认的完整执行链。任务接收程序建立统一任务实例,运行引擎组织内部处理程序,知识能力调用程序根据已赋值能力确定处理路径,方法执行程序完成具体操作,状态管理与运行记录程序保存全过程信息,闭环测试程序验证各阶段之间的正确衔接。

    至此,个体自主运行的基础程序链已经形成。个体不仅能够在本地运行环境中接收任务,而且能够根据已经赋予的知识能力进行对象处理、能力调用和方法执行,并在运行过程中管理任务状态、保存执行记录和处理异常。其自主运行能力受到知识能力赋值范围、执行规则、运行条件和安全约束的共同限制。

    本章建立的是单一个体自主运行程序的工程基础。下一阶段需要进一步研究个体如何利用已赋予的知识结构和能力形成对任务对象、对象状态、任务条件及其相互关系的认知处理,使自主运行从程序调度和能力调用进一步进入个体认知、判断与决策过程。

    这将构成第三十一章个体认知处理机制的工程研究基础。

Leave a Reply

Your email address will not be published. Required fields are marked *

客服咨询
● 欢迎咨询与合作
您好!欢迎咨询。 我可以帮助您了解人工智能技术研发、智能软件系统开发、网站建设、搜索优化及项目定制等相关信息。 请问有什么可以帮您?
免费申请
请填写以下信息,方便我们进一步沟通。
欢迎咨询 AI 系统开发、网站建设、搜索优化、项目定制合作
电话:15089196448
邮箱:1602401899@qq.com
地址:陕西省渭南市
服务时间:周一至周五 09:00 - 18:00 | 7×24小时技术值守