南向风扇电源驱动适配指南 ​

// gen/include/device_tree/interface/PowerSupply.h（namespace dev::gen）
class MC_API PowerSupply : public mc::engine::interface<PowerSupply> {
public:
    MC_INTERFACE("bmc.dev.PowerSupply")

    property<std::string> FirmwareVersion;  // 电源固件版本
    property<std::string> Manufacturer;     // 厂商
    property<std::string> Model;            // 电源型号
    property<std::string> SerialNumber;     // 序列号
    property<uint32_t>    SlotNumber;       // 槽位号
    // ...
};

// 厂商接口实现类（dev 命名空间）
class IPowerSupply : public mc::engine::interface<IPowerSupply, gen::PowerSupply> {
public:
    void init(OnePowerBase* base_ptr);
    void start();   // 内部注册更新回调
    void stop();
    bool update_power_supply(std::string_view property, const mc::variant& info);
private:
    OnePowerBase* m_base;
};

// .cpp 文件末尾：反射注册（单参数，无需列出 gen 基类）
MC_REFLECT(dev::IPowerSupply)

// drivers/psu/pmbus/one_power.cpp：PMBus 协议工厂表（节选）
#define DEFINE_PS_PROTOCOL(name, ClassType)                                  \
    {name, [](mc::dict& data) -> std::unique_ptr<ps_protocol_t> {           \
        return std::make_unique<ClassType>(data);                            \
    }}

static const ps_protocol_map_t pmbus_protocol_map = {
    DEFINE_PS_PROTOCOL("pmbus", pmbus),
    DEFINE_PS_PROTOCOL("pmbus_qb900", pmbus_qb900),
    DEFINE_PS_PROTOCOL("pmbus_FP1420", pmbus_FP1420),
    DEFINE_PS_PROTOCOL("psu_pmbus", pmbus_FP1420),
    // ...
};

// 读取属性（接口方法大多返回 std::optional，便于判空/重试）
auto voltage = m_ps_protocol->get_input_voltage();       // 输入电压(V)
auto current = m_ps_protocol->get_output_current_amps(); // 输出电流(A)
auto power   = m_ps_protocol->get_input_power_watts();   // 输入功率(W)
auto temp    = m_ps_protocol->get_env_temperature_celsius(); // 环境温度(℃)
auto rpm     = m_ps_protocol->get_psu_fan_speed_rpm();   // 风扇转速(RPM)

// 控制（如设置风扇 PWM 占空比，0-100）
m_ps_protocol->set_fan_speed_percent(30);

// 通过 Control 接口设置风扇最小 PWM（示例：40%）
m_power_supply_control.SetFanMinPWM(40);

// 通过协议直接控制风扇占空比
m_ps_protocol->set_fan_speed_percent(40);

#ifndef ONE_POWER_XYZ_H
#define ONE_POWER_XYZ_H

#include <mc/app/object.h>
#include <mc/engine.h>
#include <mc/timer.h>
#include <memory>
#include "../common/interface/i_power_supply.h"
#include "../common/interface/power_supply/i_control.h"
#include "../common/interface/power_supply/i_log_collection.h"
#include "../common/interface/power_supply/i_metrics.h"
#include "../common/interface/power_supply/i_oem.h"
#include "../common/interface/power_supply/i_status.h"
#include "../common/interface/power_supply/i_upgrade.h"
#include "../common/interface/shared_management.h"
#include "../common/one_power_base.h"

namespace dev {

class OnePowerXyz : public mc::app::object<OnePowerXyz>, public OnePowerBase {
public:
    // MC_OBJECT 参数：类名 / 对象类型名 / 路径模板 / 接口列表
    MC_OBJECT(
        OnePowerXyz, "OnePower", "/bmc/dev/Chassis/1/PowerSubsystem/PowerSupplies/${SlotNumber}",
        (IPowerSupply)(IPowerSupply_Control)(IPowerSupply_Metrics)(IPowerSupply_Status)
        (IPowerSupply_LogCollection)(IPowerSupply_Oem)(IPowerSupply_Upgrade)(IPowerSupply_SharedManagement))

    OnePowerXyz()  = default;
    ~OnePowerXyz() = default;

    bool init(mc::mutable_dict& csr_object, const mc::dict& connector);
    bool start();
    bool stop();
    void from_variant(const mc::dict& d, dev::OnePowerXyz& obj);

    // 实现 OnePowerBase 纯虚接口
    const ps_protocol_map_t& get_protocol_map() const override;      // 协议工厂表（协议名 -> 协议对象）
    IPowerSupply&       get_power_supply() override;                 // 返回 m_power_supply
    const IPowerSupply& get_power_supply() const override;
    IPowerSupply_SharedManagement&       get_shared_mgmt() override;
    const IPowerSupply_SharedManagement& get_shared_mgmt() const override;

    // 接口成员变量（与 MC_OBJECT / MC_REFLECT 一一对应）
    IPowerSupply                  m_power_supply;
    IPowerSupply_Control          m_power_supply_control;
    IPowerSupply_Metrics          m_power_supply_metrics;
    IPowerSupply_Status           m_power_supply_status;
    IPowerSupply_LogCollection    m_power_supply_log_collection;
    IPowerSupply_Oem              m_power_supply_oem;
    IPowerSupply_Upgrade          m_power_supply_upgrade;
    IPowerSupply_SharedManagement m_shared_mgmt;

private:
    // 协议名/物理通道（来自 .sr 静态属性）
    mc::engine::property<std::string> RefChip{"RefChip"};
    mc::engine::property<std::string> PhysicalInterface{"PhysicalInterface"};

    std::string get_active_interface() const;   // 返回 PhysicalInterface
    // 协议相关的数据采集（按需覆写 start_monitor 等）
    void read_frequency_property();
    void read_slow_property();
    bool start_oob_management() override;       // 启动带外数据采集
};

} // namespace dev

#endif // ONE_POWER_XYZ_H

MC_REFLECT(dev::OnePowerXyz,
           ((RefChip, "RefChip"))((PhysicalInterface, "PhysicalInterface"))
           ((m_power_supply, "bmc.dev.PowerSupply"))
           ((m_power_supply_control, "bmc.dev.PowerSupply.Control"))
           ((m_power_supply_metrics, "bmc.dev.PowerSupply.Metrics"))
           ((m_power_supply_status, "bmc.dev.PowerSupply.Status"))
           ((m_power_supply_log_collection, "bmc.dev.PowerSupply.LogCollection"))
           ((m_power_supply_oem, "bmc.dev.PowerSupply.Oem"))
           ((m_power_supply_upgrade, "bmc.dev.Upgrade"))
           ((m_shared_mgmt, "bmc.dev.SharedManagement")))

// one_power.cpp（节选，示意）
#include "one_power.h"
#include <mc/engine/property/ref_object.h>
#include <mc/engine/service.h>
#include <mc/log.h>
#include <mc/timer.h>
#include <xyz/pmbus_xyz.h>      // 新协议实现（libraries/xyz，若有）

namespace dev {

// 协议工厂表：协议名字符串 -> 具体协议对象（构造参数为 mc::dict&，包含芯片/总线信息）
#define DEFINE_PS_PROTOCOL(name, ClassType)                                 \
    {name, [](mc::dict& data) -> std::unique_ptr<ps_protocol_t> {          \
        return std::make_unique<ClassType>(data);                           \
    }}

static const ps_protocol_map_t xyz_protocol_map = {
    DEFINE_PS_PROTOCOL("pmbus_xyz", pmbus_xyz),
    // ...支持多个协议/厂商变种时在此追加
};

const ps_protocol_map_t& OnePowerXyz::get_protocol_map() const
{
    return xyz_protocol_map;
}

// init：from_variant 装载 .sr 静态属性，并解析 RefChip 引用（协议访问硬件的通道）
bool OnePowerXyz::init(mc::mutable_dict& csr_object, const mc::dict& connector)
{
    m_self = this;
    try {
        OnePowerXyz::from_variant(csr_object, *this);   // 装载 SlotNumber/Protocol/静态属性
        m_ref_obj = RefChip.get_value().as<mc::engine::ref_object*>();
        if (m_ref_obj == nullptr) {
            elog("OnePowerXyz init FAILED: RefChip ref_object is NULL");
            return false;
        }
    } catch (const std::exception& e) {
        elog("OnePowerXyz init FAILED: ${exception}", ("exception", e.what()));
        return false;
    }
    return true;
}

void OnePowerXyz::from_variant(const mc::dict& d, dev::OnePowerXyz& obj)
{
    mc::from_variant(d, obj);
}

// start：创建协议 -> 初始化/启动接口 -> 评估并启动带外采集
bool OnePowerXyz::start()
{
    // 1. 按 .sr 的 PhysicalInterface（协议名）创建协议对象，失败不阻断上线
    init_protocol(get_active_interface(), m_power_supply.SlotNumber.get_value().as<uint8_t>());

    // 2. 接口对象 init(base)/start()：start 时向 base 注册“属性名->属性值”更新回调
    m_power_supply.init(this);
    m_power_supply_control.init(this);
    m_power_supply_metrics.init(this);
    m_power_supply_status.init(this);
    m_power_supply_log_collection.init(this);
    m_power_supply_oem.init(this);
    m_power_supply_upgrade.init(this);
    // ...各接口 start() 统一在协议就绪后调用（参考 pmbus 实现）

    // 3. 主从/共享电源场景：按 ControlOwner 建立 BMC 主从监听，再评估是否启动采集
    setup_oob_management();
    evaluate_oob_management();
    return true;
}

bool OnePowerXyz::stop()
{
    teardown_oob_management();          // 断开主从监听、停止带外采集
    m_power_supply.stop();
    m_power_supply_control.stop();
    m_power_supply_metrics.stop();
    m_power_supply_status.stop();
    m_power_supply_oem.stop();
    m_power_supply_upgrade.stop();
    return true;
}

std::string OnePowerXyz::get_active_interface() const
{
    return PhysicalInterface.get_value().as<std::string>();   // 例："pmbus_xyz"
}

} // namespace dev

// 启动带外数据采集：首次带重试读取产品信息 + 启动周期采集（示意，参考 OnePowerPmbus）
bool OnePowerXyz::start_oob_management()
{
    if (!is_protocol_ready()) {
        ilog("OnePowerXyz protocol not ready, skip data collection");
        return false;
    }

    // 1. 启动时带重试读取产品信息，保证设备树尽早出现非零关键值
    get_dynamic_data("firmware_version", 3);
    get_dynamic_data("manufacturer", 3);
    get_dynamic_data("model", 3);
    get_dynamic_data("serial_number", 3);
    get_dynamic_data("rated_power_watts", 3);
    // ...
    get_dynamic_data("input_voltage", 5);
    get_dynamic_data("output_voltage", 5);

    // 2. 启动周期采集（500ms 定时器，由 OnePowerBase::start_monitor 管理）
    start_monitor(mc::make_shared<mc::timer>(this));
    reinit_protocol();
    return true;
}

// 周期回调（示意）：500ms 高频 + 分帧读取，参考 OnePowerPmbus::read_frequency_property()
void OnePowerXyz::read_frequency_property()
{
    get_dynamic_data("input_power_watts", 1);

    // 健康事件：告警状态位直接分发给 Status 接口
    auto [ev, health_failed] = m_ps_protocol->get_health_event();
    if (!health_failed) {
        update_property("vout", ev.output_voltage_fault);
        update_property("iout", ev.output_current_fault);
        update_property("temperature", ev.temper_fault);
        update_property("input", ev.input_voltage_fault);
        update_property("fans_1_2", ev.fan_fault);
        update_property("cml", ev.cml_fault);
        update_property("mfr_specific", ev.mfr_specific_status);
        update_property("other", ev.other_fault);
    }

    // 每 6 次（约 3s）读取一组动态指标：电压/电流/温度/风扇转速等
    static uint8_t cnt = 0;
    if (++cnt >= 6) {
        get_dynamic_data("output_power_watts", 1);
        get_dynamic_data("input_current_amps", 1);
        get_dynamic_data("output_current_amps", 1);
        get_dynamic_data("env_temperature_celsius", 1);
        get_dynamic_data("primary_chip_temperature_celsius", 1);
        get_dynamic_data("psu_fan_speed_rpm", 1);
        cnt = 0;
    }
}

// 慢速属性：每约 5s 读取控制数据/设备模式等（示意）
void OnePowerXyz::read_slow_property()
{
    auto control = m_ps_protocol->get_ps_control_data();
    if (control.has_value()) {
        m_power_supply_control.SleepMode = control->sleep_mode;
        m_power_supply_control.WorkMode  = control->work_mode;
        update_property("normal_and_redundancy_supported",
                        mc::variant(control->normal_and_redundancy_supported ? 1 : 0));
    }
    get_dynamic_data("equipment_mode", 1);
    get_dynamic_data("rated_power_watts", 1);
}

// interface/power_supply/i_metrics.h
class IPowerSupply_Metrics : public mc::engine::interface<IPowerSupply_Metrics, gen::PowerSupply_Metrics> {
public:
    void init(OnePowerBase* base_ptr);   // 保存 base 指针
    void start();                        // 注册指标更新回调
    void stop();                         // 注销回调
    bool update_metrics(std::string_view property, const mc::variant& info);
private:
    OnePowerBase* m_base;
};

// interface/power_supply/i_metrics.cpp
namespace dev {

void IPowerSupply_Metrics::start()
{
    register_metrics_handler();
}

void IPowerSupply_Metrics::init(OnePowerBase* base_ptr)
{
    m_base = base_ptr;
}

void IPowerSupply_Metrics::register_metrics_handler()
{
    if (!m_base) {
        elog("register_metrics_handler failed, OnePowerBase is null");
        return;
    }
    // 向公共基类注册更新回调：属性名 -> 更新本接口属性
    m_base->register_update_interface(this, [this](std::string_view property, const mc::variant& info) -> bool {
        return update_metrics(property, info);
    });
}

bool IPowerSupply_Metrics::update_metrics(std::string_view property, const mc::variant& info)
{
    if (property == "input_power_watts") {
        InputPowerWatts = info.as<double>();
        return true;
    }
    if (property == "input_voltage") {
        InputVoltage = info.as<double>();
        return true;
    }
    // output_power_watts / output_voltage / env_temperature_celsius / psu_fan_speed_rpm ...
    return false;
}

} // namespace dev

MC_REFLECT(dev::IPowerSupply_Metrics)   // 单参数反射注册，无需列出 gen 基类

#include <devmon/driver_abi.h>
#include <mc/log.h>

#include "one_power.h"

#ifndef DEVICE_DRIVER_NAME
#define DEVICE_DRIVER_NAME "psu_xyz"    // 与 .sr 的 Compatible、协议名对应
#endif

using namespace dev;

extern "C" {

driver_handle_t create_one_power(void* service, const char* name)
{
    try {
        if (service == nullptr || name == nullptr) {
            return nullptr;
        }
        auto* device = new OnePowerXyz();
        device->set_service(static_cast<mc::engine::service*>(service));
        device->set_object_name(name);
        return device;
    } catch (const std::exception& e) {
        elog("create_one_power failed: ${error}", ("error", e.what()));
        return nullptr;
    }
}

status_t init_one_power(driver_handle_t device, void* csr_object, void* connector)
{
    if (device == nullptr || csr_object == nullptr || connector == nullptr) {
        return STATUS_ERROR;
    }
    auto*           device_object  = static_cast<OnePowerXyz*>(device);
    mc::mutable_dict* csr_object_ptr = static_cast<mc::mutable_dict*>(csr_object);
    mc::dict*         connector_ptr  = static_cast<mc::dict*>(connector);
    return device_object->init(*csr_object_ptr, *connector_ptr) ? STATUS_OK : STATUS_ERROR;
}

status_t start_one_power(driver_handle_t device)
{
    if (device == nullptr) {
        return STATUS_ERROR;
    }
    return static_cast<OnePowerXyz*>(device)->start() ? STATUS_OK : STATUS_ERROR;
}

status_t stop_one_power(driver_handle_t device)
{
    if (device == nullptr) {
        return STATUS_ERROR;
    }
    static_cast<OnePowerXyz*>(device)->stop();
    return STATUS_OK;
}

// device_name 与 .sr 的 Unit.Type（电源为 "PSU"）对应
device_driver_t one_power_device_driver = {.device_name = "PSU",
                                           .ctor        = create_one_power,
                                           .init        = init_one_power,
                                           .start       = start_one_power,
                                           .stop        = stop_one_power};

device_driver_t psu_device_driver[] = {one_power_device_driver};

status_t register_device_driver(device_driver_t** device_driver, uint8_t* count)
{
    *device_driver = psu_device_driver;
    *count         = sizeof(psu_device_driver) / sizeof(psu_device_driver[0]);
    return STATUS_OK;
}
}

ilog("OnePowerXyz ${slot} started, protocol=${protocol}",
     ("slot", m_power_supply.SlotNumber)("protocol", get_active_interface()));

try {
    auto value = m_ps_protocol->get_input_voltage();
    if (!value.has_value()) {
        elog("Failed to get input voltage");
        return false;
    }
} catch (const std::exception& e) {
    elog("Exception caught: ${error}", ("error", e.what()));
    return false;
}

// 500ms 定时器，回调内区分快慢属性（参考 OnePowerPmbus 实现）
m_property_query_timer->timeout.connect([this]() {
    read_frequency_property();                 // 每次 500ms：功率、健康事件等

    static uint8_t slow_cnt = 0;               // 慢属性：约每 10 次（5s）读取
    if (++slow_cnt >= 10) {
        read_slow_property();
        slow_cnt = 0;
    }
});
m_property_query_timer->set_single_shot(false);
m_property_query_timer->start(mc::milliseconds(500));

// 清理定时器
if (m_property_query_timer) {
    m_property_query_timer->stop();
    m_property_query_timer.reset();
}

// 1) 接口映射单测：验证“snake_case 属性名 -> 接口属性”的分发逻辑（无需硬件）
TEST(i_power_supply_metrics, update_metrics_mapping) {
    dev::IPowerSupply_Metrics metrics;
    EXPECT_TRUE(metrics.update_metrics("input_power_watts", mc::variant(100.0)));
    EXPECT_TRUE(metrics.update_metrics("input_voltage", mc::variant(220.0)));
    // 校验 InputPowerWatts / InputVoltage 属性已更新...
}

// 2) 协议层单测：mock 底层总线（参考 tests/libraries/smbus/chip_mock.*），
//    直接验证协议类（如厂商 PMBus 变种）的属性读取/命令解析
TEST(pmbus_variant, read_input_voltage) {
    MockChip chip;                 // 打桩 I2C/SMBus 读写
    mc::dict data{{"chip", ...}};
    pmbus_xyz proto(data);         // 厂商变种协议对象
    auto v = proto.get_input_voltage();
    EXPECT_TRUE(v.has_value());
}

// 周期回调（示意）：健康事件 -> Status 接口，含风扇故障位
auto [ev, health_failed] = m_ps_protocol->get_health_event();
if (!health_failed) {
    update_property("fans_1_2", ev.fan_fault);   // 驱动把故障位交给 Status 接口
    update_property("vout", ev.output_voltage_fault);
    // ...
}

// libraries/pmbus/pmbus_xyz.h（示意）：厂商变种协议子类
class pmbus_xyz : public pmbus {
public:
    explicit pmbus_xyz(mc::dict& data) : pmbus(data) {}

    // 厂商差异点：覆写风扇转速/私有属性读取等
    std::optional<uint16_t>    get_psu_fan_speed_rpm() override;
    std::optional<std::string> get_firmware_version() override;
};

// drivers/psu/pmbus/one_power.cpp：注册进协议工厂表
// DEFINE_PS_PROTOCOL("psu_xyz", pmbus_xyz), ...

// 读取失败自动重试（例如启动阶段读产品信息，失败率高的场景给 3-5 次）
bool ok = get_dynamic_data("psu_fan_speed_rpm", 3);