EnerOS v0.24.0 Release Notes

Release Date: August 24, 2025 Codename: OpsAuto Git Tag: v0.24.0 Support Status: Stable Total Crates: 60 (4 new) Test Cases: 7600+ (500+ new)

Overview

EnerOS v0.24.0 “OpsAuto” is a specialized release for operations automation, upgrading power system operations from “human-driven” to “Agent-driven.” Power system operations cover equipment inspection, fault handling, maintenance scheduling, spare parts management, and other aspects, traditionally highly dependent on human experience. v0.24.0 brings operations knowledge, processes, and tools down to kernel services, enabling Agents to autonomously complete inspection, self-healing, predictive maintenance, and other tasks, and consolidating operational experience into a reusable knowledge base.

This version introduces four core capabilities: Auto Inspection, Self-Healing, Predictive Maintenance, and Ops Knowledge Base, unified as the eneros-ops operations suite. Agents can schedule drones, robots, SCADA, and other execution resources through syscalls to complete end-to-end operational closed loops.

In terms of design philosophy, v0.24.0 implements “operations as code”—operational processes are defined in executable code form (Runbook as Code), with each execution’s process and results persisted for audit, forming a traceable, reviewable, and optimizable operational closed loop. It also adheres to “human-in-the-loop”—high-risk operations still require human confirmation, with Agents only providing recommendations and contingency plans.

Key Metrics

New Features

1. Operations Automation Framework

Introduced the eneros-ops Crate, providing a unified operations automation framework. All operational tasks are defined as Runbooks, scheduled and executed by Agents.

Runbook Definition

use eneros_ops::{Runbook, Step, Executor};

let runbook = Runbook::new("transformer-inspection")
    .description("Transformer periodic inspection")
    .step(Step::new("check-oil-temp")
        .executor(Executor::Scada)
        .command("read-analog {device}.oil_temp"))
    .step(Step::new("check-load")
        .executor(Executor::Scada)
        .command("read-analog {device}.load_mva"))
    .step(Step::new("visual-inspection")
        .executor(Executor::Drone)
        .command("capture {device.location} resolution=4k"))
    .step(Step::new("analyze")
        .executor(Executor::Agent)
        .command("analyze-inspection-result"))
    .on_failure(Step::new("notify")
        .command("notify-ops-team severity=warning"));

runbook.execute(&device).await?;

Execution Resources

2. Auto Inspection

Introduced the eneros-ops-inspection Crate, providing automatic inspection capabilities. It intelligently schedules inspection plans based on equipment type, operating status, and historical defects, dispatching drones, robots, and other execution resources to complete inspections.

Inspection Planning

use eneros_ops_inspection::{InspectionPlanner, InspectionTask};

let planner = InspectionPlanner::new(&network)
    .strategy(Strategy::RiskBased)  // Risk-based
    .interval_range(
        Duration::days(7),    // Minimum 7 days
        Duration::days(90),   // Maximum 90 days
    );

// Generate inspection plan
let plan = planner.generate_plan().await?;

for task in plan.tasks() {
    println!("{}: {} - priority {}",
        task.scheduled_at, task.device, task.priority);
}

Inspection Execution

// Schedule drone to execute inspection
let task = InspectionTask::new("line-42-inspection")
    .target(LineId::from(42))
    .items(vec![
        InspectionItem::Visual,
        InspectionItem::Thermal,
        InspectionItem::Corona,
    ])
    .executor(Executor::Drone)
    .route(optimal_route(&line_42).await?);

let result = task.execute().await?;

// Infrared thermography results
for spot in result.thermal_hotspots() {
    if spot.temperature_c > 80.0 {
        log::warn!("Hotspot: {} {:.1}°C", spot.location, spot.temperature_c);
    }
}

Inspection Equipment Coverage

3. Self-Healing

Introduced the eneros-ops-selfheal Crate, providing fault self-healing capabilities. When grid faults occur, Agents automatically execute the closed-loop process of fault localization, isolation, load transfer, and power restoration.

Self-Healing Flow

use eneros_ops_selfheal::{SelfHealEngine, FaultEvent};

let engine = SelfHealEngine::new(&swarm)
    .auto_isolate(true)         // Auto isolate
    .auto_restore(true)         // Auto restore
    .max_restore_time(Duration::minutes(3));

// Listen for fault events
engine.on_fault(|event: FaultEvent| async move {
    // 1. Fault localization
    let location = engine.locate_fault(&event).await?;
    
    // 2. Fault isolation
    let isolated = engine.isolate(location).await?;
    
    // 3. Load transfer
    let transferred = engine.transfer_load(isolated.affected_area).await?;
    
    // 4. Power restoration
    let restored = engine.restore(transferred).await?;
    
    println!("Self-healing complete: restored {} customers", restored.customers);
    Ok(())
});

Self-Healing Statistics

4. Predictive Maintenance

Introduced the eneros-ops-predictive Crate, providing predictive maintenance capabilities. Based on equipment operating data (temperature, vibration, partial discharge, oil chromatography), it uses machine learning models to predict equipment health and remaining life.

Health Assessment

use eneros_ops_predictive::{HealthModel, DeviceHealth};

let model = HealthModel::load("transformer-health-v2")?;

// Assess transformer health
let health: DeviceHealth = model.evaluate(&transformer).await?;

println!("Health score: {:.1}/100", health.score);
println!("Remaining life: {:.0} days", health.remaining_life_days);

for risk in health.risks() {
    println!("Risk: {} (probability {:.0}%)", risk.description, risk.probability * 100.0);
}

Fault Prediction

// Predict failure probability for next 7 days
let forecast = model.forecast(&transformer, Duration::days(7)).await?;

if forecast.failure_probability > 0.15 {
    // Trigger preventive maintenance
    let work_order = MaintenancePlanner::new()
        .device(&transformer)
        .priority(Priority::High)
        .window(forecast.suggested_window)
        .create().await?;
}

Health Metrics

5. Ops Knowledge Base

Introduced the eneros-ops-knowledge Crate, providing an operations knowledge base. It structurally stores historical operational experience, fault cases, and contingency plans, supporting semantic search.

Knowledge Search

use eneros_ops_knowledge::{KnowledgeBase, Query};

let kb = KnowledgeBase::open("ops-kb")?;

// Semantic search
let results = kb.search(Query::semantic("How to handle transformer oil temperature too high"))
    .top(5)
    .execute().await?;

for r in results {
    println!("[{:.2}] {}", r.score, r.title);
    println!("  {}", r.summary);
}

Case Consolidation

// Write operational cases to knowledge base
let case = Case::new("case-2025-08-15-001")
    .title("110kV main transformer oil temperature too high handling")
    .symptom("Oil temperature 85°C, exceeding alarm threshold")
    .diagnosis("Radiator fan failure")
    .action("Replace fan motor, restore cooling")
    .outcome("Oil temperature dropped to 65°C")
    .tags(vec!["transformer", "oil temperature", "cooling"]);

kb.add_case(case).await?;

Knowledge Base Structure

Improvements

• Drone Scheduling: Supports multi-drone collaborative inspection, reducing complex line inspection time by 60%
• Fault Localization: Fault localization accuracy improved to within 100m based on traveling wave method
• Knowledge Search: Introduced vector search, 92% semantic matching accuracy
• Operations Audit: All operational action records support replay, meeting MLPS 2.0 (等保 2.0) requirements

Bug Fixes

• Fixed eneros-ops-inspection drone path planning obstacle avoidance error in mountainous terrain (#2405)
• Fixed eneros-ops-selfheal suboptimal load transfer strategy in multi-source scenarios (#2410)
• Fixed eneros-ops-predictive health model crash during data gaps (#2416)
• Fixed eneros-ops-knowledge vector index memory leak during bulk updates (#2421)

Breaking Changes

• Runbook::execute: Parameter changed from &Device to &impl Executable, requires implementing Executable trait
• HealthModel::evaluate: Return type changed from f64 to DeviceHealth struct

Upgrade Guide

1. Run cargo update -p eneros-ops
2. Implement Executable trait for custom device types
3. Update HealthModel::evaluate calls to adapt to DeviceHealth return type
4. Refer to docs/migration/v0.24.0.md for detailed migration steps