实时双执行域

EnerOS 采用双执行域架构：通用执行域（General Domain）承载 Agent 编排、AI 推理、业务逻辑；实时执行域（Real-time Domain）承载保护逻辑、开关操作、闭环控制，保障 P99 < 1ms 的确定性时延。两个域通过内核态共享内存通信，避免进程切换开销。

电力系统对时延有严苛要求：继电保护必须在 4 个周波（80ms@50Hz）内动作，PMU 相量计算要求 30Hz 以上输出，闭环 AVR 控制周期在 100ms 级。通用操作系统（Linux CFS 调度）的毫秒级抖动无法满足这些场景。EnerOS 通过双执行域把「快慢分离」做到内核级。

架构总览

┌─────────────────────────────────────────────────┐
│           通用执行域 (General Domain)           │
│  - Agent 编排                                   │
│  - LLM 推理                                     │
│  - 业务流程                                     │
│  - 时序分析                                     │
│  - 调度：CFS（完全公平调度器）                  │
└──────────────────┬──────────────────────────────┘
                   │ 共享内存 / 无锁队列
                   │ 延迟 < 10μs
┌──────────────────┴──────────────────────────────┐
│           实时执行域 (Real-time Domain)         │
│  - 保护逻辑 (4ms)                               │
│  - 闭环控制 (1ms)                               │
│  - 开关操作 (100μs)                             │
│  - 相量计算 (250μs)                             │
│  - 调度：SCHED_FIFO / PREEMPT_RT / Xenomai      │
└─────────────────────────────────────────────────┘

域职责划分

实时域任务定义

实时任务通过 RealtimeTask trait 定义，遵循周期触发模型：

use eneros_realtime::{RealtimeTask, RtContext, RtResult};
use std::time::Duration;

struct ProtectionLogic {
    period: Duration,
    breaker_id: u32,
    zone_reach: f64,  // Ω
}

impl RealtimeTask for ProtectionLogic {
    fn period(&self) -> Duration { self.period }

    fn priority(&self) -> i32 { 99 }  // SCHED_FIFO 优先级

    fn cpu_affinity(&self) -> Option<Vec<u32>> {
        Some(vec![0, 1])  // 绑定到 CPU 0,1
    }

    fn run(&mut self, ctx: &mut RtContext) -> RtResult<()> {
        // 读取 PMU 数据（共享内存，零拷贝）
        let pmu = ctx.pmu_snapshot();

        // 距离保护算法
        let z_seen = self.compute_impedance(&pmu);
        if z_seen < self.zone_reach {
            // 立即跳闸（无锁通道，< 100μs）
            ctx.trip_breaker(self.breaker_id);
            ctx.log_event(ProtectionEvent::Trip {
                impedance: z_seen,
                reach: self.zone_reach,
            });
        }

        Ok(())
    }
}

impl ProtectionLogic {
    fn compute_impedance(&self, pmu: &PmuSnapshot) -> f64 {
        let v = pmu.voltage_complex();
        let i = pmu.current_complex();
        (v / i).norm()
    }
}

RealtimeTask trait 方法

任务调度

实时域采用基于优先级的抢占式调度，配合 Linux PREEMPT_RT 或 Xenomai：

use eneros_realtime::{RtScheduler, SchedPolicy, IsolationConfig};

let mut sched = RtScheduler::new()
    .policy(SchedPolicy::Fifo)
    .cpu_affinity(0..2)  // 隔离 CPU 0,1
    .isolate_from_general(true)
    .isolation(IsolationConfig {
        isolcpus: true,           // 内核启动参数 isolcpus
        nohz_full: true,          // NO_HZ_FULL
        rcu_nocbs: true,          // RCU 卸载
        huge_pages: true,         // 大页内存
        disable_irq: true,        // 禁用 IRQ
    });

sched.spawn(ProtectionLogic::new(Duration::from_micros(4000), brk_id, 5.0));
sched.spawn(ClosedLoopControl::new(Duration::from_millis(1)));
sched.spawn(BreakerOperation::new(Duration::from_micros(100)));
sched.spawn(PhasorCalculator::new(Duration::from_micros(250)));
sched.start()?;

SchedPolicy 变体

跨域通信

两个域通过无锁环形队列通信，避免锁竞争与缓存抖动：

use eneros_realtime::cross::{Channel, Message, ChannelConfig};

let (tx, rx) = Channel::unbounded::<ControlCmd>(
    ChannelConfig {
        capacity: 1024,
        spin_wait_us: 5,
        cache_align: true,
    },
);

// 通用域 → 实时域
tx.send(ControlCmd::SetVoltage(1.02))?;

// 实时域接收（非阻塞）
if let Some(cmd) = rx.try_recv() {
    match cmd {
        ControlCmd::SetVoltage(v) => self.target_voltage = v,
        ControlCmd::TripBreaker(id) => ctx.trip_breaker(id),
    }
}

// 实时域 → 通用域（事件上报）
let (evt_tx, evt_rx) = Channel::bounded::<RtEvent>(256);
evt_tx.send(RtEvent::BreakerTripped { id: 5, reason: "overcurrent" });

Channel 类型

跨域消息延迟

确定性保证

内核启动参数示例

# /etc/default/grub
GRUB_CMDLINE_LINUX="isolcpus=0,1 nohz_full=0,1 rcu_nocbs=0,1 \
    hugepagesz=2M hugepages=512 iommu=pt intel_idle.max_cstate=0 \
    processor.max_cstate=0 idle=poll"

任务类型与周期

RtContext API

实时任务上下文提供的 API：

use eneros_realtime::RtContext;

impl RtContext {
    // 数据访问（共享内存，零拷贝）
    pub fn pmu_snapshot(&self) -> PmuSnapshot;
    pub fn rtu_snapshot(&self) -> RtuSnapshot;
    pub fn network_state(&self) -> NetworkState;

    // 控制输出
    pub fn trip_breaker(&self, id: u32);
    pub fn close_breaker(&self, id: u32);
    pub fn set_excitation(&self, gen_id: u32, v: f64);
    pub fn set_tap(&self, xfmr_id: u32, tap: i16);

    // 通信
    pub fn send_event(&self, evt: RtEvent);
    pub fn try_recv_cmd(&self) -> Option<ControlCmd>;

    // 日志（lock-free）
    pub fn log_event(&self, evt: impl Event);
    pub fn waveform_record(&self, data: &WaveformBuffer);

    // 时间
    pub fn now(&self) -> Timestamp;
    pub fn elapsed(&self) -> Duration;
}

故障切换

通用域故障不会影响实时域：实时域检测到通用域心跳超时后，自动切换到「安全模式」，按预设策略运行。

use eneros_realtime::SafetyMode;

sched.on_general_domain_timeout(|| {
    // 切换到安全模式
    SafetyMode::island_operation()
        .hold_frequency(50.0)
        .hold_voltage(1.0)
        .disable_remote_control()
        .enable_local_protection()
        .activate();
});

// 心跳配置
sched.heartbeat_config(HeartbeatConfig {
    interval: Duration::from_millis(100),
    timeout: Duration::from_millis(500),
    on_missed: HeartbeatAction::Warn,
    on_timeout: HeartbeatAction::EnterSafetyMode,
});

SafetyMode 行为

性能指标

测试环境：Intel Xeon 4 核 / 8GB / Ubuntu 22.04 + PREEMPT_RT。

配置参数

eneros.toml 中实时域相关配置：

[realtime]
# 调度策略：fifo / round_robin / deadline / xenomai
policy = "fifo"
# 实时 CPU 核（与 isolcpus 一致）
cpus = [0, 1]
# 大页内存（MB）
huge_pages_mb = 1024
# 是否启用看门狗
watchdog = true
# 看门狗超时（ms）
watchdog_timeout_ms = 100
# 心跳间隔（ms）
heartbeat_interval_ms = 100
# 心跳超时（ms）
heartbeat_timeout_ms = 500
# 故障切换安全模式
safety_mode_on_timeout = true
# 实时任务最大数
max_tasks = 256

与其他能力的关系

相关文档

• 安全守卫 — 实时域命令也经过网关
• 数字孪生引擎 — 与实时域同步
• 设备模型库 — 实时域设备模型
• 多智能体协作 — 保护类 Agent 运行环境
• EnerOS 简介 — Real-Time Determinism 设计哲学