分层架构

EnerOS 采用严格的五层架构，从上到下依次为：应用层、Agent 运行时、电力原生内核、实时安全网关、基础设施。每一层只能依赖下层，禁止跨层调用与反向依赖，通过 Cargo workspace 的依赖约束在编译期强制保证。

设计原则

架构层次总览

┌─────────────────────────────────────────────────────────────────────┐
│  L5  应用层 (Application Layer)                                      │
│      调度 · 运维 · 交易 · 规划 · 能效 · 自愈 · 数字孪生              │
│      [DispatchAgent] [OperationAgent] [TradingAgent]                │
│      [PlanningAgent] [SelfHealingAgent] [ForecastAgent]             │
├─────────────────────────────────────────────────────────────────────┤
│  L4  Agent 运行时 (Agent Runtime)                                    │
│      7 领域 Agent · 多智能体协作 · 记忆/工具/推理/学习               │
│      [eneros-agent] [eneros-reasoning] [eneros-memory]              │
│      [eneros-tool] [eneros-ai] [eneros-twin] [eneros-nl]            │
├─────────────────────────────────────────────────────────────────────┤
│  L3  电力原生内核 (Power-Native Kernel)                             │
│      拓扑 · 潮流 · 约束 · 设备 · 时序 · 分析 · 事件                 │
│      [eneros-topology] [eneros-powerflow] [eneros-constraint]       │
│      [eneros-equipment] [eneros-timeseries] [eneros-analysis]       │
│      [eneros-eventbus] [eneros-cnpower] [eneros-emtp]              │
├─────────────────────────────────────────────────────────────────────┤
│  L2  实时安全网关 (Real-Time Safety Gateway)                        │
│      mTLS · CA · IDS · 审计 · 合规 · 网关 · 信任                     │
│      [eneros-gateway] [eneros-trust] [eneros-ids]                   │
│      [eneros-audit] [eneros-compliance]                             │
├─────────────────────────────────────────────────────────────────────┤
│  L1  基础设施 (Infrastructure)                                       │
│      OS 服务 · 网络 · 存储 · 多区域 · 多租户 · 协议 · 设备           │
│      [eneros-os] [eneros-network] [eneros-multiregion]              │
│      [eneros-tenant] [eneros-scada] [eneros-device]                 │
│      [eneros-protocol-*] [eneros-perf] [eneros-core]               │
└─────────────────────────────────────────────────────────────────────┘

层间数据流

                 ┌──────────────────┐
                 │   用户 / SCADA   │
                 └────────┬─────────┘
                          │ REST / GraphQL / WebSocket / SSE
                          ▼
┌─────────────────────────────────────────────────────────────────┐
│ L5 应用层                                                         │
│   DispatchAgent.plan() → TradingAgent.bid() → ...               │
└────────┬────────────────────────────────────────────────────────┘
         │ Agent SDK 调用（system_call）
         ▼
┌─────────────────────────────────────────────────────────────────┐
│ L4 Agent 运行时                                                   │
│   lifecycle / orchestrator / reasoning / memory / tool           │
└────────┬────────────────────────────────────────────────────────┘
         │ 内核系统调用（Kernel API）
         ▼
┌─────────────────────────────────────────────────────────────────┐
│ L3 电力原生内核                                                   │
│   topology.analyze() → powerflow.solve() → constraint.check()   │
└────────┬────────────────────────────────────────────────────────┘
         │ 命令下发（Command）
         ▼
┌─────────────────────────────────────────────────────────────────┐
│ L2 实时安全网关                                                   │
│   gateway.execute_command() → trust.verify() → audit.log()      │
└────────┬────────────────────────────────────────────────────────┘
         │ 设备操作（Device Op）
         ▼
┌─────────────────────────────────────────────────────────────────┐
│ L1 基础设施                                                       │
│   device.write() → scada.scan() → timeseries.write()            │
└─────────────────────────────────────────────────────────────────┘

L5 - 应用层（Application Layer）

应用层是 EnerOS 的最上层，承载面向电力业务的具体场景。每个应用由一个或多个领域 Agent 组成，通过 Agent 运行时调用内核能力。

职责

• 业务流程编排（调度、运维、交易、规划）
• 用户交互（CLI、Web、API 客户端）
• 报表与可视化
• 第三方系统集成

应用组件

应用层代码示例

use eneros_agent::dispatch_agent::DispatchAgent;
use eneros_core::Command;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // 创建调度 Agent
    let mut agent = DispatchAgent::builder()
        .with_name("dispatch-001")
        .with_region("east-grid")
        .build()
        .await?;

    // 执行经济调度
    let plan = agent.run_economic_dispatch().await?;
    println!("调度计划: {} 台机组参与", plan.generators.len());

    // 通过安全网关下发控制命令
    for gen in &plan.generators {
        let cmd = Command::new_generator_setpoint(
            gen.id,
            gen.target_mw,
            "dispatch-001",
        );
        agent.gateway().execute_command(cmd).await?;
    }

    Ok(())
}

L4 - Agent 运行时（Agent Runtime）

Agent 运行时提供 Agent 的完整生命周期管理、多智能体协作、推理与学习能力。

职责

• Agent 生命周期（创建、暂停、恢复、销毁、迁移）
• 多智能体协作（Orchestrator 编排）
• 记忆系统（短期/长期/向量记忆）
• 工具引擎（工具注册、调用、权限）
• 推理引擎（LLM 集成、ReAct/CoT 策略）
• 学习与反思（RL、反思、解释）

组件详解

Agent 运行时代码示例

use eneros_agent::{Agent, AgentBuilder, Orchestrator};
use eneros_memory::MemoryStore;
use eneros_tool::ToolRegistry;
use eneros_reasoning::ReasoningEngine;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // 1. 构建记忆系统
    let memory = MemoryStore::builder()
        .short_term_capacity(100)
        .long_term_path("./data/memory")?
        .build();

    // 2. 构建工具引擎
    let mut tools = ToolRegistry::new();
    tools.register(Box::new(eneros_tool::builtin::TopologyTool::new()));
    tools.register(Box::new(eneros_tool::builtin::PowerflowTool::new()));
    tools.register(Box::new(eneros_tool::builtin::ConstraintTool::new()));

    // 3. 构建推理引擎
    let reasoning = ReasoningEngine::builder()
        .strategy(eneros_reasoning::Strategy::ReAct)
        .max_iterations(10)
        .build();

    // 4. 构建 Agent
    let mut agent = AgentBuilder::new()
        .name("grid-assistant")
        .memory(memory)
        .tools(tools)
        .reasoning(reasoning)
        .build()
        .await?;

    // 5. 执行任务
    let result = agent
        .run("分析当前电网拓扑，找出电压越限节点")
        .await?;

    println!("分析结果: {}", result.answer);

    // 6. 多 Agent 协作
    let orchestrator = Orchestrator::new();
    orchestrator.register_agent(agent);
    orchestrator.register_agent(DispatchAgent::new().await?);
    orchestrator.register_agent(OperationAgent::new().await?);

    let plan = orchestrator
        .coordinate("处理电网电压越限问题")
        .await?;

    Ok(())
}

L3 - 电力原生内核（Power-Native Kernel）

电力原生内核是 EnerOS 的核心，将电力系统的领域知识、物理约束与运行逻辑内建为内核一等公民。

职责

• 电网拓扑建模与分析
• 潮流计算与状态估计
• 安全约束校验与投影
• 设备模型库
• 时序数据存储
• 高级分析（OPF、短路、DSA）
• 事件总线与发布订阅

内核组件

内核代码示例

use eneros_topology::{TopologyEngine, Bus, Branch, Switch};
use eneros_powerflow::PowerflowSolver;
use eneros_constraint::{ConstraintEngine, Constraint, ConstraintKind};
use eneros_timeseries::{TimeseriesEngine, Point};

fn main() -> anyhow::Result<()> {
    // 1. 构建电网拓扑
    let mut topo = TopologyEngine::new();
    topo.add_bus(Bus::new(1, "Bus-1", 138.0));
    topo.add_bus(Bus::new(2, "Bus-2", 138.0));
    topo.add_bus(Bus::new(3, "Bus-3", 138.0));
    topo.add_branch(Branch::new(1, 1, 2, 0.01, 0.05));
    topo.add_branch(Branch::new(2, 2, 3, 0.02, 0.08));
    topo.add_switch(Switch::new(1, 3, 1, true));

    // 2. 拓扑分析
    let islands = topo.find_islands()?;
    println!("电气岛数量: {}", islands.len());
    let paths = topo.shortest_path(1, 3)?;
    println!("Bus-1 到 Bus-3 路径: {:?}", paths);

    // 3. 潮流计算
    let mut solver = PowerflowSolver::new(topo.graph());
    let result = solver.solve_newton_raphson()?;
    println!("收敛: {} 次迭代", result.iterations);
    for bus in &result.buses {
        println!("Bus {}: V={:.4}pu, θ={:.2}°", bus.id, bus.voltage, bus.angle);
    }

    // 4. 约束校验
    let mut constraints = ConstraintEngine::new();
    constraints.add_constraint(Constraint::new(
        ConstraintKind::VoltageLimit,
        "V_min".to_string(),
        0.95,
        1.05,
    ));
    constraints.add_constraint(Constraint::new(
        ConstraintKind::ThermalLimit,
        "Line-1".to_string(),
        0.0,
        100.0,
    ));
    let violations = constraints.check(&result)?;
    for v in &violations {
        println!("违反约束: {} = {:.4}", v.constraint_id, v.value);
    }

    // 5. 时序数据写入
    let mut ts = TimeseriesEngine::open("./data/ts")?;
    ts.write_point(Point::new(
        "bus-1-voltage",
        chrono::Utc::now(),
        result.buses[0].voltage,
    ))?;

    Ok(())
}

L2 - 实时安全网关（Real-Time Safety Gateway）

实时安全网关是双执行域之间的桥梁，确保所有跨域命令经过安全校验，并提供零信任、入侵检测、审计与合规能力。

职责

• 命令拦截与安全校验
• 零信任 mTLS 通信
• 入侵检测（行为基线 + IOC）
• 审计日志（HMAC 签名 + WORM 存储）
• 合规检查（NERC CIP / IEC 62443 / GDPR / PIPL）
• 优先级排序与可行性投影

网关组件

安全网关代码示例

use eneros_gateway::SafetyGateway;
use eneros_trust::{MtlsConfig, CertManager};
use eneros_audit::AuditLogger;
use eneros_ids::IntrusionDetector;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // 1. 初始化零信任 mTLS
    let cert_manager = CertManager::builder()
        .ca_cert_path("./certs/ca.pem")
        .server_cert_path("./certs/server.pem")
        .server_key_path("./certs/server.key")
        .build()?;
    let mtls = MtlsConfig::from_cert_manager(&cert_manager)?;

    // 2. 初始化审计日志（HMAC + WORM）
    let audit = AuditLogger::builder()
        .storage_path("./audit")
        .hmac_key(b"audit-secret-key-32-bytes-long!")
        .worm_enabled(true)
        .build()?;

    // 3. 初始化入侵检测
    let ids = IntrusionDetector::builder()
        .baseline_window(chrono::Duration::hours(24))
        .alert_threshold(0.8)
        .build()?;

    // 4. 构建安全网关
    let gateway = SafetyGateway::new(10000)
        .with_lockfree_state();

    // 5. 注册安全检查
    gateway.register_safety_check(Box::new(audit.clone()));
    gateway.register_safety_check(Box::new(ids.clone()));

    // 6. 执行命令（自动审计 + 入侵检测）
    let cmd = eneros_core::Command::new_switch_toggle(42, false, "operator-1");
    gateway.execute_command(cmd).await?;

    // 7. 查询审计历史
    let history = gateway.command_history();
    println!("审计记录数: {}", history.len());

    Ok(())
}

L1 - 基础设施（Infrastructure）

基础设施层提供操作系统服务、网络、存储、多区域、多租户、协议适配与设备管理能力。

职责

• OS 服务（init / rt / agentos / hal）
• 网络配置与防火墙
• 多区域复制与灾备
• 多租户隔离与配额
• SCADA 数据采集
• 设备协议适配（IEC 104 / Modbus / DNP3 / PMU / MQTT）
• 性能优化（arena / pool / ring buffer）

基础设施组件

协议适配

基础设施代码示例

use eneros_os::rt::{RtConfig, RtRuntime};
use eneros_multiregion::{MultiRegionManager, RegionConfig};
use eneros_tenant::{TenantManager, TenantConfig};
use eneros_scada::{ScadaCollector, ProtocolType};
use eneros_device::{DeviceManager, ProtocolConfig};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // 1. 配置实时运行时
    let rt_config = RtConfig {
        cpus: vec![2, 3],
        priority: 80,
        lock_memory: true,
        use_huge_pages: true,
    };
    let rt = RtRuntime::new(rt_config);
    rt.configure_current_thread()?;

    // 2. 多区域复制
    let region = MultiRegionManager::new(RegionConfig {
        local_region: "east-1".to_string(),
        peer_regions: vec!["west-1".to_string(), "north-1".to_string()],
        replication_mode: eneros_multiregion::ReplicationMode::AsyncWal,
    });

    // 3. 多租户隔离
    let tenants = TenantManager::new(TenantConfig {
        default_quota: eneros_tenant::Quota {
            max_agents: 100,
            max_storage_gb: 100,
            max_requests_per_sec: 1000,
        },
    });
    tenants.create_tenant("tenant-001", "电力公司 A").await?;

    // 4. SCADA 数据采集
    let mut scada = ScadaCollector::new();
    scada.add_channel("rtu-1", ProtocolType::Iec104, "192.168.1.10:2404")?;
    scada.add_channel("rtu-2", ProtocolType::Cdt, "192.168.1.11:2404")?;
    scada.start().await?;

    // 5. 设备管理
    let devices = DeviceManager::new();
    devices
        .register_device(
            "rtu-1",
            Box::new(eneros_device::adapter::ModbusAdapter::new()),
            eneros_device::adapter::ConnectionConfig {
                host: "192.168.1.10".into(),
                port: 502,
                timeout_ms: 3000,
                credentials: None,
                protocol_config: ProtocolConfig::Modbus {
                    slave_id: 1,
                    baud_rate: None,
                },
            },
            eneros_device::adapter::DeviceInfo {
                device_id: "rtu-1".into(),
                name: "RTU-1".into(),
                protocol: eneros_device::protocol::ProtocolType::Modbus,
                manufacturer: "Siemens".into(),
                model: "S7-1500".into(),
                firmware_version: "1.0.0".into(),
                ip_address: "192.168.1.10".into(),
                port: 502,
                capabilities: vec!["read".into(), "write".into()],
            },
        )
        .await;

    Ok(())
}

层间接口规范

L5 → L4：Agent SDK

应用层通过 Agent SDK 调用运行时能力，接口形式为 Rust trait + async 方法：

// L4 暴露给 L5 的接口
pub trait AgentRuntime: Send + Sync {
    async fn create_agent(&self, config: AgentConfig) -> Result<AgentHandle>;
    async fn invoke_agent(&self, handle: &AgentHandle, input: AgentInput) -> Result<AgentOutput>;
    async fn destroy_agent(&self, handle: AgentHandle) -> Result<()>;
}

L4 → L3：内核系统调用

Agent 运行时通过内核系统调用访问电力原生能力：

// L3 暴露给 L4 的接口
pub trait PowerNativeKernel: Send + Sync {
    fn topology(&self) -> &dyn TopologyApi;
    fn powerflow(&self) -> &dyn PowerflowApi;
    fn constraint(&self) -> &dyn ConstraintApi;
    fn timeseries(&self) -> &dyn TimeseriesApi;
    fn eventbus(&self) -> &dyn EventBusApi;
}

pub trait TopologyApi: Send + Sync {
    fn find_islands(&self) -> Result<Vec<Vec<BusId>>>;
    fn shortest_path(&self, from: BusId, to: BusId) -> Result<Vec<BusId>>;
}

L3 → L2：命令下发

内核通过命令对象将控制指令下发到安全网关：

// L2 暴露给 L3 的接口
pub trait SafetyGatewayApi: Send + Sync {
    async fn execute_command(&self, cmd: Command) -> Result<ExecutionResult>;
    async fn validate_command(&self, cmd: &Command) -> Result<()>;
    fn command_history(&self) -> Vec<Command>;
}

L2 → L1：设备操作

安全网关通过设备管理器访问物理设备：

// L1 暴露给 L2 的接口
pub trait DeviceManagerApi: Send + Sync {
    async fn read(&self, device_id: &str, address: &str) -> Result<DataValue>;
    async fn write(&self, device_id: &str, address: &str, value: DataValue) -> Result<()>;
    async fn connect(&self, device_id: &str) -> Result<()>;
    async fn disconnect(&self, device_id: &str) -> Result<()>;
}

各层组件完整对照表

相关文档

• 双执行架构 - 双执行域详解
• Crate 依赖关系 - Crate 依赖图
• 项目结构 - 目录结构说明