using System.Diagnostics;
|
using Aging.Infrastructure.Contracts;
|
using log4net;
|
|
namespace Aging.Infrastructure.Services
|
{
|
/// <summary>
|
/// 电源配置命令
|
/// </summary>
|
public sealed class PowerCommand
|
{
|
/// <summary>
|
/// 目标电压值（可选，单位: V）
|
/// </summary>
|
public double? Voltage { get; set; }
|
|
/// <summary>
|
/// 目标电流限制值（可选，单位: A）
|
/// </summary>
|
public double? CurrentLimit { get; set; }
|
|
/// <summary>
|
/// 输出开关状态（true=ON, false=OFF, null=不改变）
|
/// </summary>
|
public bool? Output { get; set; }
|
}
|
|
/// <summary>
|
/// 电源操作结果
|
/// </summary>
|
public sealed class PowerOperationResult
|
{
|
/// <summary>
|
/// 操作是否成功
|
/// </summary>
|
public bool Success { get; set; }
|
|
/// <summary>
|
/// 实测电压值（单位: V）
|
/// </summary>
|
public double? MeasuredVoltage { get; set; }
|
|
/// <summary>
|
/// 实测电流值（单位: A）
|
/// </summary>
|
public double? MeasuredCurrent { get; set; }
|
|
/// <summary>
|
/// 设备原始响应字符串
|
/// </summary>
|
public string? RawResponse { get; set; }
|
|
/// <summary>
|
/// 错误代码
|
/// </summary>
|
public string? ErrorCode { get; set; }
|
|
/// <summary>
|
/// 错误信息
|
/// </summary>
|
public string? ErrorMessage { get; set; }
|
|
/// <summary>
|
/// 操作延迟（毫秒）
|
/// </summary>
|
public double LatencyMs { get; set; }
|
|
/// <summary>
|
/// 创建一个成功的结果
|
/// </summary>
|
public static PowerOperationResult Succeed(double? voltage, double? current, string? rawResponse, double latencyMs)
|
{
|
return new PowerOperationResult
|
{
|
Success = true,
|
MeasuredVoltage = voltage,
|
MeasuredCurrent = current,
|
RawResponse = rawResponse,
|
LatencyMs = latencyMs
|
};
|
}
|
|
/// <summary>
|
/// 创建一个失败的结果
|
/// </summary>
|
public static PowerOperationResult Failed(string errorCode, string errorMessage, double latencyMs)
|
{
|
return new PowerOperationResult
|
{
|
Success = false,
|
ErrorCode = errorCode,
|
ErrorMessage = errorMessage,
|
LatencyMs = latencyMs
|
};
|
}
|
}
|
|
/// <summary>
|
/// 电源配置服务 - 面向 Slot 的高层电源操作。
|
/// 通过 SlotDeviceMappingResolver 解析 Slot 到具体设备端点的映射，
|
/// 协调 ResourceManager 和 DeviceManager 完成电源配置、测量和状态查询。
|
/// </summary>
|
public sealed class PowerSupplyService
|
{
|
private static readonly ILog Log = LogManager.GetLogger(typeof(PowerSupplyService));
|
|
/// <summary>
|
/// 资源管理器
|
/// </summary>
|
private readonly IResourceManager _resourceManager;
|
|
/// <summary>
|
/// 设备管理器
|
/// </summary>
|
private readonly IDeviceManager _deviceManager;
|
|
/// <summary>
|
/// Slot-设备-通道映射解析器
|
/// </summary>
|
private readonly SlotDeviceMappingResolver _slotMappingResolver;
|
|
/// <summary>
|
/// 初始化电源配置服务实例
|
/// </summary>
|
/// <param name="resourceManager">资源管理器</param>
|
/// <param name="deviceManager">设备管理器</param>
|
/// <param name="slotMappingResolver">Slot 映射解析器</param>
|
public PowerSupplyService(
|
IResourceManager resourceManager,
|
IDeviceManager deviceManager,
|
SlotDeviceMappingResolver slotMappingResolver)
|
{
|
_resourceManager = resourceManager ?? throw new ArgumentNullException(nameof(resourceManager));
|
_deviceManager = deviceManager ?? throw new ArgumentNullException(nameof(deviceManager));
|
_slotMappingResolver = slotMappingResolver ?? throw new ArgumentNullException(nameof(slotMappingResolver));
|
}
|
|
/// <summary>
|
/// 异步配置 Slot 对应的电源参数。
|
/// 根据 SlotId 解析映射获取设备端点，验证资源预约后发送 SCPI 命令配置电源。
|
/// </summary>
|
/// <param name="slotId">Slot 标识符</param>
|
/// <param name="command">电源配置命令</param>
|
/// <param name="owner">所有者令牌</param>
|
/// <param name="ct">取消令牌</param>
|
/// <returns>电源操作结果，包含测量值</returns>
|
public async Task<PowerOperationResult> ConfigureAsync(
|
string slotId, PowerCommand command, ResourceOwnerToken owner, CancellationToken ct)
|
{
|
if (string.IsNullOrWhiteSpace(slotId))
|
throw new ArgumentException("SlotId 不能为空", nameof(slotId));
|
if (command == null)
|
throw new ArgumentNullException(nameof(command));
|
if (owner == null)
|
throw new ArgumentNullException(nameof(owner));
|
|
var stopwatch = Stopwatch.StartNew();
|
|
try
|
{
|
Log.Info($"[PowerSupplyService] 配置电源: Slot={slotId}, Owner={owner.OwnerId}");
|
|
// 1. 解析 Slot 映射
|
var endpoint = _slotMappingResolver.ResolveEndpoint(slotId, "PowerSupply");
|
if (endpoint == null)
|
{
|
stopwatch.Stop();
|
Log.Warn($"[PowerSupplyService] Slot {slotId} 未找到 PowerSupply 映射");
|
return PowerOperationResult.Failed("MAPPING_NOT_FOUND",
|
$"Slot {slotId} 未找到 PowerSupply 类型的设备映射", stopwatch.Elapsed.TotalMilliseconds);
|
}
|
|
var resourceKey = endpoint.ToResourceKey();
|
|
// 2. 验证预约
|
if (!_resourceManager.ValidateOwner(owner, resourceKey))
|
{
|
stopwatch.Stop();
|
Log.Warn($"[PowerSupplyService] 权限验证失败: Slot={slotId}, Device={endpoint.DeviceId}, Owner={owner.OwnerId}");
|
return PowerOperationResult.Failed("PERMISSION_DENIED",
|
$"所有者 {owner.OwnerId} 未预约 Slot {slotId} 对应的设备 {endpoint.DeviceId} 或令牌已过期",
|
stopwatch.Elapsed.TotalMilliseconds);
|
}
|
|
// 3. 获取租约
|
using var lease = await _resourceManager.AcquireOperationAsync(owner, resourceKey, ct).ConfigureAwait(false);
|
|
// 4. 获取设备驱动
|
var driver = _deviceManager.GetDriver(endpoint.DeviceId);
|
if (driver == null)
|
{
|
stopwatch.Stop();
|
Log.Warn($"[PowerSupplyService] 设备 {endpoint.DeviceId} 驱动不存在");
|
return PowerOperationResult.Failed("DRIVER_NOT_FOUND",
|
$"设备 {endpoint.DeviceId} 的驱动未注册", stopwatch.Elapsed.TotalMilliseconds);
|
}
|
|
// 5. 构建并发送 SCPI 命令
|
var scpiCommands = BuildScpiCommands(command);
|
foreach (var scpiCommand in scpiCommands)
|
{
|
Log.Info($"[PowerSupplyService] 发送 SCPI 命令: Device={endpoint.DeviceId}, Command={scpiCommand}");
|
await driver.SendCommandAsync(scpiCommand, ct).ConfigureAwait(false);
|
}
|
|
// 6. 回读测量值
|
string rawResponse;
|
try
|
{
|
// 优先尝试 MEAS:ALL? 一次性获取所有测量值
|
rawResponse = await driver.QueryAsync("MEAS:ALL?", ct).ConfigureAwait(false);
|
Log.Info($"[PowerSupplyService] MEAS:ALL? 响应: {rawResponse}");
|
}
|
catch
|
{
|
// 如果 MEAS:ALL? 失败，分别查询电压和电流
|
Log.Info($"[PowerSupplyService] MEAS:ALL? 失败，尝试分别查询 VOLT? 和 CURR?");
|
var voltageResponse = await driver.QueryAsync("VOLT?", ct).ConfigureAwait(false);
|
var currentResponse = await driver.QueryAsync("CURR?", ct).ConfigureAwait(false);
|
rawResponse = $"{voltageResponse},{currentResponse}";
|
}
|
|
// 7. 解析回读值
|
ParseMeasurementResponse(rawResponse, out var measuredVoltage, out var measuredCurrent);
|
|
stopwatch.Stop();
|
Log.Info($"[PowerSupplyService] 电源配置完成: Slot={slotId}, Device={endpoint.DeviceId}, " +
|
$"V={measuredVoltage}, I={measuredCurrent}, 延迟={stopwatch.Elapsed.TotalMilliseconds:F2}ms");
|
|
return PowerOperationResult.Succeed(measuredVoltage, measuredCurrent, rawResponse,
|
stopwatch.Elapsed.TotalMilliseconds);
|
}
|
catch (ResourceConflictException ex)
|
{
|
stopwatch.Stop();
|
Log.Error($"[PowerSupplyService] 资源冲突: Slot={slotId}, 错误: {ex.Message}", ex);
|
return PowerOperationResult.Failed("RESOURCE_CONFLICT", ex.Message, stopwatch.Elapsed.TotalMilliseconds);
|
}
|
catch (OperationCanceledException)
|
{
|
stopwatch.Stop();
|
Log.Warn($"[PowerSupplyService] 电源配置被取消: Slot={slotId}");
|
return PowerOperationResult.Failed("OPERATION_CANCELLED", "操作已被取消",
|
stopwatch.Elapsed.TotalMilliseconds);
|
}
|
catch (TimeoutException ex)
|
{
|
stopwatch.Stop();
|
Log.Error($"[PowerSupplyService] 电源配置超时: Slot={slotId}, 错误: {ex.Message}", ex);
|
return PowerOperationResult.Failed("TIMEOUT", $"电源配置超时: {ex.Message}",
|
stopwatch.Elapsed.TotalMilliseconds);
|
}
|
catch (Exception ex)
|
{
|
stopwatch.Stop();
|
Log.Error($"[PowerSupplyService] 电源配置异常: Slot={slotId}, 错误: {ex.Message}", ex);
|
return PowerOperationResult.Failed("UNKNOWN_ERROR", $"电源配置失败: {ex.Message}",
|
stopwatch.Elapsed.TotalMilliseconds);
|
}
|
}
|
|
/// <summary>
|
/// 异步测量 Slot 对应电源的输出值（电压、电流）。
|
/// 根据 SlotId 解析映射获取设备端点，查询实时测量值。
|
/// </summary>
|
/// <param name="slotId">Slot 标识符</param>
|
/// <param name="owner">所有者令牌</param>
|
/// <param name="ct">取消令牌</param>
|
/// <returns>电源操作结果，包含测量值</returns>
|
public async Task<PowerOperationResult> MeasureAsync(
|
string slotId, ResourceOwnerToken owner, CancellationToken ct)
|
{
|
if (string.IsNullOrWhiteSpace(slotId))
|
throw new ArgumentException("SlotId 不能为空", nameof(slotId));
|
if (owner == null)
|
throw new ArgumentNullException(nameof(owner));
|
|
var stopwatch = Stopwatch.StartNew();
|
|
try
|
{
|
Log.Info($"[PowerSupplyService] 测量电源: Slot={slotId}, Owner={owner.OwnerId}");
|
|
// 1. 解析 Slot 映射
|
var endpoint = _slotMappingResolver.ResolveEndpoint(slotId, "PowerSupply");
|
if (endpoint == null)
|
{
|
stopwatch.Stop();
|
Log.Warn($"[PowerSupplyService] Slot {slotId} 未找到 PowerSupply 映射");
|
return PowerOperationResult.Failed("MAPPING_NOT_FOUND",
|
$"Slot {slotId} 未找到 PowerSupply 类型的设备映射", stopwatch.Elapsed.TotalMilliseconds);
|
}
|
|
var resourceKey = endpoint.ToResourceKey();
|
|
// 2. 验证预约
|
if (!_resourceManager.ValidateOwner(owner, resourceKey))
|
{
|
stopwatch.Stop();
|
Log.Warn($"[PowerSupplyService] 权限验证失败: Slot={slotId}, Device={endpoint.DeviceId}, Owner={owner.OwnerId}");
|
return PowerOperationResult.Failed("PERMISSION_DENIED",
|
$"所有者 {owner.OwnerId} 未预约 Slot {slotId} 对应的设备 {endpoint.DeviceId} 或令牌已过期",
|
stopwatch.Elapsed.TotalMilliseconds);
|
}
|
|
// 3. 获取租约
|
using var lease = await _resourceManager.AcquireOperationAsync(owner, resourceKey, ct).ConfigureAwait(false);
|
|
// 4. 获取设备驱动
|
var driver = _deviceManager.GetDriver(endpoint.DeviceId);
|
if (driver == null)
|
{
|
stopwatch.Stop();
|
Log.Warn($"[PowerSupplyService] 设备 {endpoint.DeviceId} 驱动不存在");
|
return PowerOperationResult.Failed("DRIVER_NOT_FOUND",
|
$"设备 {endpoint.DeviceId} 的驱动未注册", stopwatch.Elapsed.TotalMilliseconds);
|
}
|
|
// 5. 查询测量值
|
string rawResponse;
|
try
|
{
|
rawResponse = await driver.QueryAsync("MEAS:ALL?", ct).ConfigureAwait(false);
|
}
|
catch
|
{
|
var voltageResponse = await driver.QueryAsync("VOLT?", ct).ConfigureAwait(false);
|
var currentResponse = await driver.QueryAsync("CURR?", ct).ConfigureAwait(false);
|
rawResponse = $"{voltageResponse},{currentResponse}";
|
}
|
|
// 6. 解析回读值
|
ParseMeasurementResponse(rawResponse, out var measuredVoltage, out var measuredCurrent);
|
|
stopwatch.Stop();
|
Log.Info($"[PowerSupplyService] 测量完成: Slot={slotId}, Device={endpoint.DeviceId}, " +
|
$"V={measuredVoltage}, I={measuredCurrent}, 延迟={stopwatch.Elapsed.TotalMilliseconds:F2}ms");
|
|
return PowerOperationResult.Succeed(measuredVoltage, measuredCurrent, rawResponse,
|
stopwatch.Elapsed.TotalMilliseconds);
|
}
|
catch (ResourceConflictException ex)
|
{
|
stopwatch.Stop();
|
Log.Error($"[PowerSupplyService] 资源冲突: Slot={slotId}, 错误: {ex.Message}", ex);
|
return PowerOperationResult.Failed("RESOURCE_CONFLICT", ex.Message, stopwatch.Elapsed.TotalMilliseconds);
|
}
|
catch (OperationCanceledException)
|
{
|
stopwatch.Stop();
|
Log.Warn($"[PowerSupplyService] 测量操作被取消: Slot={slotId}");
|
return PowerOperationResult.Failed("OPERATION_CANCELLED", "操作已被取消",
|
stopwatch.Elapsed.TotalMilliseconds);
|
}
|
catch (TimeoutException ex)
|
{
|
stopwatch.Stop();
|
Log.Error($"[PowerSupplyService] 测量操作超时: Slot={slotId}, 错误: {ex.Message}", ex);
|
return PowerOperationResult.Failed("TIMEOUT", $"测量操作超时: {ex.Message}",
|
stopwatch.Elapsed.TotalMilliseconds);
|
}
|
catch (Exception ex)
|
{
|
stopwatch.Stop();
|
Log.Error($"[PowerSupplyService] 测量操作异常: Slot={slotId}, 错误: {ex.Message}", ex);
|
return PowerOperationResult.Failed("UNKNOWN_ERROR", $"测量操作失败: {ex.Message}",
|
stopwatch.Elapsed.TotalMilliseconds);
|
}
|
}
|
|
/// <summary>
|
/// 异步获取 Slot 对应电源的当前状态（电压、电流、输出开关状态）。
|
/// </summary>
|
/// <param name="slotId">Slot 标识符</param>
|
/// <param name="owner">所有者令牌</param>
|
/// <param name="ct">取消令牌</param>
|
/// <returns>电源操作结果，包含状态信息</returns>
|
public async Task<PowerOperationResult> GetPowerStatusAsync(
|
string slotId, ResourceOwnerToken owner, CancellationToken ct)
|
{
|
if (string.IsNullOrWhiteSpace(slotId))
|
throw new ArgumentException("SlotId 不能为空", nameof(slotId));
|
if (owner == null)
|
throw new ArgumentNullException(nameof(owner));
|
|
var stopwatch = Stopwatch.StartNew();
|
|
try
|
{
|
Log.Info($"[PowerSupplyService] 查询电源状态: Slot={slotId}, Owner={owner.OwnerId}");
|
|
// 1. 解析 Slot 映射
|
var endpoint = _slotMappingResolver.ResolveEndpoint(slotId, "PowerSupply");
|
if (endpoint == null)
|
{
|
stopwatch.Stop();
|
Log.Warn($"[PowerSupplyService] Slot {slotId} 未找到 PowerSupply 映射");
|
return PowerOperationResult.Failed("MAPPING_NOT_FOUND",
|
$"Slot {slotId} 未找到 PowerSupply 类型的设备映射", stopwatch.Elapsed.TotalMilliseconds);
|
}
|
|
var resourceKey = endpoint.ToResourceKey();
|
|
// 2. 验证预约
|
if (!_resourceManager.ValidateOwner(owner, resourceKey))
|
{
|
stopwatch.Stop();
|
Log.Warn($"[PowerSupplyService] 权限验证失败: Slot={slotId}, Device={endpoint.DeviceId}, Owner={owner.OwnerId}");
|
return PowerOperationResult.Failed("PERMISSION_DENIED",
|
$"所有者 {owner.OwnerId} 未预约 Slot {slotId} 对应的设备 {endpoint.DeviceId} 或令牌已过期",
|
stopwatch.Elapsed.TotalMilliseconds);
|
}
|
|
// 3. 获取租约
|
using var lease = await _resourceManager.AcquireOperationAsync(owner, resourceKey, ct).ConfigureAwait(false);
|
|
// 4. 获取设备驱动
|
var driver = _deviceManager.GetDriver(endpoint.DeviceId);
|
if (driver == null)
|
{
|
stopwatch.Stop();
|
Log.Warn($"[PowerSupplyService] 设备 {endpoint.DeviceId} 驱动不存在");
|
return PowerOperationResult.Failed("DRIVER_NOT_FOUND",
|
$"设备 {endpoint.DeviceId} 的驱动未注册", stopwatch.Elapsed.TotalMilliseconds);
|
}
|
|
// 5. 查询电压、电流和输出状态
|
var voltageResponse = await driver.QueryAsync("VOLT?", ct).ConfigureAwait(false);
|
var currentResponse = await driver.QueryAsync("CURR?", ct).ConfigureAwait(false);
|
var outputResponse = await driver.QueryAsync("OUTP?", ct).ConfigureAwait(false);
|
|
var rawResponse = $"VOLT={voltageResponse},CURR={currentResponse},OUTP={outputResponse}";
|
|
// 6. 解析测量值
|
ParseMeasurementResponse($"{voltageResponse},{currentResponse}",
|
out var measuredVoltage, out var measuredCurrent);
|
|
stopwatch.Stop();
|
Log.Info($"[PowerSupplyService] 电源状态查询完成: Slot={slotId}, Device={endpoint.DeviceId}, " +
|
$"V={measuredVoltage}, I={measuredCurrent}, OUTP={outputResponse}, " +
|
$"延迟={stopwatch.Elapsed.TotalMilliseconds:F2}ms");
|
|
return new PowerOperationResult
|
{
|
Success = true,
|
MeasuredVoltage = measuredVoltage,
|
MeasuredCurrent = measuredCurrent,
|
RawResponse = rawResponse,
|
LatencyMs = stopwatch.Elapsed.TotalMilliseconds
|
};
|
}
|
catch (ResourceConflictException ex)
|
{
|
stopwatch.Stop();
|
Log.Error($"[PowerSupplyService] 资源冲突: Slot={slotId}, 错误: {ex.Message}", ex);
|
return PowerOperationResult.Failed("RESOURCE_CONFLICT", ex.Message, stopwatch.Elapsed.TotalMilliseconds);
|
}
|
catch (OperationCanceledException)
|
{
|
stopwatch.Stop();
|
Log.Warn($"[PowerSupplyService] 状态查询被取消: Slot={slotId}");
|
return PowerOperationResult.Failed("OPERATION_CANCELLED", "操作已被取消",
|
stopwatch.Elapsed.TotalMilliseconds);
|
}
|
catch (TimeoutException ex)
|
{
|
stopwatch.Stop();
|
Log.Error($"[PowerSupplyService] 状态查询超时: Slot={slotId}, 错误: {ex.Message}", ex);
|
return PowerOperationResult.Failed("TIMEOUT", $"状态查询超时: {ex.Message}",
|
stopwatch.Elapsed.TotalMilliseconds);
|
}
|
catch (Exception ex)
|
{
|
stopwatch.Stop();
|
Log.Error($"[PowerSupplyService] 状态查询异常: Slot={slotId}, 错误: {ex.Message}", ex);
|
return PowerOperationResult.Failed("UNKNOWN_ERROR", $"状态查询失败: {ex.Message}",
|
stopwatch.Elapsed.TotalMilliseconds);
|
}
|
}
|
|
/// <summary>
|
/// 根据电源配置命令构建 SCPI 命令列表
|
/// </summary>
|
/// <param name="command">电源配置命令</param>
|
/// <returns>SCPI 命令字符串列表</returns>
|
private static List<string> BuildScpiCommands(PowerCommand command)
|
{
|
var commands = new List<string>();
|
|
if (command.Voltage.HasValue)
|
{
|
commands.Add($"VOLT {command.Voltage.Value:G}");
|
}
|
|
if (command.CurrentLimit.HasValue)
|
{
|
commands.Add($"CURR {command.CurrentLimit.Value:G}");
|
}
|
|
if (command.Output.HasValue)
|
{
|
commands.Add(command.Output.Value ? "OUTP ON" : "OUTP OFF");
|
}
|
|
return commands;
|
}
|
|
/// <summary>
|
/// 解析设备返回的测量值响应字符串。
|
/// 支持格式: "voltage,current" 或单个数值。
|
/// </summary>
|
/// <param name="rawResponse">原始响应字符串</param>
|
/// <param name="voltage">解析后的电压值</param>
|
/// <param name="current">解析后的电流值</param>
|
private static void ParseMeasurementResponse(string rawResponse, out double? voltage, out double? current)
|
{
|
voltage = null;
|
current = null;
|
|
if (string.IsNullOrWhiteSpace(rawResponse))
|
return;
|
|
try
|
{
|
var parts = rawResponse.Split(',');
|
|
if (parts.Length >= 1 && double.TryParse(parts[0].Trim(), out var v))
|
{
|
voltage = v;
|
}
|
|
if (parts.Length >= 2 && double.TryParse(parts[1].Trim(), out var c))
|
{
|
current = c;
|
}
|
}
|
catch (Exception)
|
{
|
// 解析失败时保持 null 值
|
}
|
}
|
}
|
}
|
