Browse Source

feat: 重构RanAPICommandHandler架构 - 引入抽象基类和接口拆分

- 拆分IRanAPICommandHandler接口为多个专门接口
  * IRanAPICommandHandler: 基础接口,包含日志配置功能
  * IRanPowerControlHandler: 功率控制接口,包含发送/接收功率设置
  * IRanGainControlHandler: 增益控制接口,包含发送/接收增益设置

- 新增RanAPICommandHandlerBase抽象基类
  * 提供通用命令执行逻辑ExecuteCommandAsync
  * 提供工具方法BuildCommandPrefix、ValidateRanEndPoint
  * 统一异常处理和资源管理

- 优化RanAPICommandHandler实现类
  * 继承抽象基类,实现所有接口
  * 使用基类通用方法,减少重复代码
  * 统一命令执行模式:await ExecuteCommandAsync(command, "操作名称")
  * 统一参数验证:ValidateRanEndPoint(ranEndPoint)

- 新增功率控制功能
  * SetTxPowerAsync/SetRxPowerAsync: 字典格式设置功率
  * SetAllTxPowerAsync/SetAllRxPowerAsync: 数组格式批量设置功率
  * 支持动态长度数组,按端口顺序排列

- 文件结构优化
  * 按功能模块拆分接口文件
  * 提高代码组织清晰度和可维护性
  * 支持模块化依赖注入和独立测试

影响范围: RAN API命令处理器架构重构、接口设计模块化、代码复用和维护性提升
feature/protocol-log-Perfect
root 4 months ago
parent
commit
7d4386d710
  1. 85
      CoreAgent.Domain/Interfaces/Network/IRanAPICommandHandler.cs
  2. 42
      CoreAgent.Domain/Interfaces/Network/IRanGainControlHandler.cs
  3. 42
      CoreAgent.Domain/Interfaces/Network/IRanPowerControlHandler.cs
  4. 5
      CoreAgent.Infrastructure/Services/Network/ProtocolClientConfigFactory.cs
  5. 564
      CoreAgent.Infrastructure/Services/Network/RanAPICommandHandler.cs
  6. 2
      CoreAgent.ProtocolClient/Models/ProtocolClientConfig.cs
  7. 6545
      modify.md

85
CoreAgent.Domain/Interfaces/Network/IRanAPICommandHandler.cs

@ -0,0 +1,85 @@
using CoreAgent.Domain.Interfaces.System.Command;
using CoreAgent.Domain.Models.Network;
using CoreAgent.Domain.Models.System;
namespace CoreAgent.Domain.Interfaces.Network;
/// <summary>
/// RAN API 命令处理器基础接口
/// 负责处理各种RAN相关的API操作命令
/// </summary>
public interface IRanAPICommandHandler
{
/// <summary>
/// 设置 RAN 日志配置
/// </summary>
/// <param name="ranEndPoint">RAN 端点信息</param>
/// <param name="enableBcch">是否启用BCCH日志</param>
/// <returns>是否成功设置配置</returns>
Task<bool> SetRanLogsConfigAsync(RanIPEndPoint ranEndPoint, bool enableBcch);
}
/// <summary>
/// RAN API 命令处理器抽象基类
/// 提供通用的命令执行逻辑
/// </summary>
public abstract class RanAPICommandHandlerBase : IRanAPICommandHandler
{
protected readonly ISystemCommandExecutor _commandExecutor;
protected readonly AppSettings _appSettings;
protected RanAPICommandHandlerBase(ISystemCommandExecutor commandExecutor, AppSettings appSettings)
{
_commandExecutor = commandExecutor ?? throw new ArgumentNullException(nameof(commandExecutor));
_appSettings = appSettings ?? throw new ArgumentNullException(nameof(appSettings));
}
/// <summary>
/// 执行命令的通用方法
/// </summary>
/// <param name="command">要执行的命令</param>
/// <param name="operationName">操作名称,用于日志记录</param>
/// <param name="parameters">操作参数,用于日志记录</param>
/// <returns>命令执行结果</returns>
protected async Task<CommandExecutionResult> ExecuteCommandAsync(string command, string operationName, object parameters = null)
{
try
{
var result = await _commandExecutor.ExecuteCommandAsync(command, new CancellationTokenSource());
return result;
}
catch (Exception ex)
{
// 这里可以添加通用的异常处理逻辑
throw new InvalidOperationException($"执行{operationName}命令时发生异常: {ex.Message}", ex);
}
}
/// <summary>
/// 构建命令前缀
/// </summary>
/// <param name="ranEndPoint">RAN 端点信息</param>
/// <returns>命令前缀</returns>
protected string BuildCommandPrefix(RanIPEndPoint ranEndPoint)
{
return $"{_appSettings.WebSocketJsPath} {ranEndPoint.ComAddr}";
}
/// <summary>
/// 验证RAN端点
/// </summary>
/// <param name="ranEndPoint">RAN 端点信息</param>
/// <returns>是否有效</returns>
protected bool ValidateRanEndPoint(RanIPEndPoint ranEndPoint)
{
return ranEndPoint != null;
}
/// <summary>
/// 设置 RAN 日志配置
/// </summary>
/// <param name="ranEndPoint">RAN 端点信息</param>
/// <param name="enableBcch">是否启用BCCH日志</param>
/// <returns>是否成功设置配置</returns>
public abstract Task<bool> SetRanLogsConfigAsync(RanIPEndPoint ranEndPoint, bool enableBcch);
}

42
CoreAgent.Domain/Interfaces/Network/IRanGainControlHandler.cs

@ -0,0 +1,42 @@
using CoreAgent.Domain.Models.Network;
namespace CoreAgent.Domain.Interfaces.Network;
/// <summary>
/// RAN API 增益控制接口
/// 负责处理发送和接收增益相关的操作
/// </summary>
public interface IRanGainControlHandler
{
/// <summary>
/// 设置发送增益
/// </summary>
/// <param name="ranEndPoint">RAN 端点信息</param>
/// <param name="gainSettings">增益设置字典,key为端口号(int),value为增益值(double)</param>
/// <returns>是否成功设置增益</returns>
Task<bool> SetTxGainAsync(RanIPEndPoint ranEndPoint, Dictionary<int, double> gainSettings);
/// <summary>
/// 设置接收增益
/// </summary>
/// <param name="ranEndPoint">RAN 端点信息</param>
/// <param name="gainSettings">增益设置字典,key为端口号(int),value为增益值(double)</param>
/// <returns>是否成功设置增益</returns>
Task<bool> SetRxGainAsync(RanIPEndPoint ranEndPoint, Dictionary<int, double> gainSettings);
/// <summary>
/// 设置所有端口的发送增益
/// </summary>
/// <param name="ranEndPoint">RAN 端点信息</param>
/// <param name="gainValues">所有端口的增益值数组,按端口顺序排列</param>
/// <returns>是否成功设置增益</returns>
Task<bool> SetAllTxGainAsync(RanIPEndPoint ranEndPoint, double[] gainValues);
/// <summary>
/// 设置所有端口的接收增益
/// </summary>
/// <param name="ranEndPoint">RAN 端点信息</param>
/// <param name="gainValues">所有端口的增益值数组,按端口顺序排列</param>
/// <returns>是否成功设置增益</returns>
Task<bool> SetAllRxGainAsync(RanIPEndPoint ranEndPoint, double[] gainValues);
}

42
CoreAgent.Domain/Interfaces/Network/IRanPowerControlHandler.cs

@ -0,0 +1,42 @@
using CoreAgent.Domain.Models.Network;
namespace CoreAgent.Domain.Interfaces.Network;
/// <summary>
/// RAN API 功率控制接口
/// 负责处理发送和接收功率相关的操作
/// </summary>
public interface IRanPowerControlHandler
{
/// <summary>
/// 设置发送功率
/// </summary>
/// <param name="ranEndPoint">RAN 端点信息</param>
/// <param name="powerSettings">功率设置字典,key为端口号(int),value为功率值(double)</param>
/// <returns>是否成功设置功率</returns>
Task<bool> SetTxPowerAsync(RanIPEndPoint ranEndPoint, Dictionary<int, double> powerSettings);
/// <summary>
/// 设置接收功率
/// </summary>
/// <param name="ranEndPoint">RAN 端点信息</param>
/// <param name="powerSettings">功率设置字典,key为端口号(int),value为功率值(double)</param>
/// <returns>是否成功设置功率</returns>
Task<bool> SetRxPowerAsync(RanIPEndPoint ranEndPoint, Dictionary<int, double> powerSettings);
/// <summary>
/// 设置所有端口的发送功率
/// </summary>
/// <param name="ranEndPoint">RAN 端点信息</param>
/// <param name="powerValues">所有端口的功率值数组,按端口顺序排列</param>
/// <returns>是否成功设置功率</returns>
Task<bool> SetAllTxPowerAsync(RanIPEndPoint ranEndPoint, double[] powerValues);
/// <summary>
/// 设置所有端口的接收功率
/// </summary>
/// <param name="ranEndPoint">RAN 端点信息</param>
/// <param name="powerValues">所有端口的功率值数组,按端口顺序排列</param>
/// <returns>是否成功设置功率</returns>
Task<bool> SetAllRxPowerAsync(RanIPEndPoint ranEndPoint, double[] powerValues);
}

5
CoreAgent.Infrastructure/Services/Network/ProtocolClientConfigFactory.cs

@ -150,8 +150,9 @@ namespace CoreAgent.Infrastructure.Services.Network
Ssl = ssl,
Logs = new ProtocolClientLogsConfig
{
Signal = false,
Cch = false,
Signal = model == "RAN" ? true : null,
Cch = model == "RAN" ? true : null,
Bcch = model == "RAN" ? false : null,
Layers = getLayers()
},
Model = model

564
CoreAgent.Infrastructure/Services/Network/RanAPICommandHandler.cs

@ -0,0 +1,564 @@
using CoreAgent.Domain.Interfaces.Network;
using CoreAgent.Domain.Interfaces.System.Command;
using CoreAgent.Domain.Models.Network;
using CoreAgent.Domain.Models.System;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
namespace CoreAgent.Infrastructure.Services.Network;
/// <summary>
/// RAN API 命令处理器实现
/// 负责处理各种RAN相关的API操作命令
/// </summary>
public class RanAPICommandHandler : RanAPICommandHandlerBase, IRanPowerControlHandler, IRanGainControlHandler
{
private readonly ILogger<RanAPICommandHandler> _logger;
public RanAPICommandHandler(
ILogger<RanAPICommandHandler> logger,
ISystemCommandExecutor commandExecutor,
IOptions<AppSettings> appSettings)
: base(commandExecutor, appSettings.Value)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
/// <summary>
/// 设置 RAN 日志配置
/// </summary>
/// <param name="ranEndPoint">RAN 端点信息</param>
/// <param name="enableBcch">是否启用BCCH日志</param>
/// <returns>是否成功设置配置</returns>
public override async Task<bool> SetRanLogsConfigAsync(RanIPEndPoint ranEndPoint, bool enableBcch)
{
if (!ValidateRanEndPoint(ranEndPoint))
{
_logger.LogWarning("RAN 端点未配置");
return false;
}
try
{
var configCommand = $@"{{""message"":""config_set"",""logs"":{{""bcch"":{enableBcch.ToString().ToLower()}}}}}";
var command = $"{BuildCommandPrefix(ranEndPoint)} '{configCommand}'";
_logger.LogInformation("开始设置RAN日志配置,地址: {ComAddr}, 启用BCCH: {EnableBcch}", ranEndPoint.ComAddr, enableBcch);
var result = await ExecuteCommandAsync(command, "RAN日志配置设置");
if (result.IsSuccess)
{
_logger.LogInformation("RAN日志配置设置成功,地址: {ComAddr}, 启用BCCH: {EnableBcch}", ranEndPoint.ComAddr, enableBcch);
return true;
}
else
{
_logger.LogWarning("RAN日志配置设置失败,地址: {ComAddr}, 启用BCCH: {EnableBcch}, 错误: {Error}",
ranEndPoint.ComAddr, enableBcch, result.Error);
return false;
}
}
catch (Exception ex)
{
_logger.LogError(ex, "设置RAN日志配置时发生异常,地址: {ComAddr}, 启用BCCH: {EnableBcch}", ranEndPoint.ComAddr, enableBcch);
return false;
}
}
#region 功率控制方法
/// <summary>
/// 设置发送功率
/// </summary>
/// <param name="ranEndPoint">RAN 端点信息</param>
/// <param name="powerSettings">功率设置字典,key为端口号(int),value为功率值(double)</param>
/// <returns>是否成功设置功率</returns>
public async Task<bool> SetTxPowerAsync(RanIPEndPoint ranEndPoint, Dictionary<int, double> powerSettings)
{
if (!ValidateRanEndPoint(ranEndPoint))
{
_logger.LogWarning("RAN 端点未配置");
return false;
}
if (powerSettings == null || powerSettings.Count == 0)
{
_logger.LogWarning("功率设置字典为空或无效");
return false;
}
try
{
var successCount = 0;
var totalCount = powerSettings.Count;
_logger.LogInformation("开始批量设置发送功率,地址: {ComAddr}, 端口数量: {PortCount}", ranEndPoint.ComAddr, totalCount);
foreach (var setting in powerSettings)
{
var port = setting.Key;
var setPower = setting.Value;
var cmd_setPower = $"{BuildCommandPrefix(ranEndPoint)} '{{""message"":""rf"",""tx_power"":{setPower},""tx_channel_index"":{port}}}'";
_logger.LogDebug("设置端口 {Port} 的发送功率值为 {SetPower}", port, setPower);
var result = await ExecuteCommandAsync(cmd_setPower, "发送功率设置");
if (result.IsSuccess)
{
successCount++;
_logger.LogDebug("端口 {Port} 发送功率设置成功,功率值: {SetPower}", port, setPower);
}
else
{
_logger.LogWarning("端口 {Port} 发送功率设置失败,功率值: {SetPower}, 错误: {Error}",
port, setPower, result.Error);
}
}
var allSuccess = successCount == totalCount;
if (allSuccess)
{
_logger.LogInformation("所有端口发送功率设置成功,地址: {ComAddr}, 成功数量: {SuccessCount}/{TotalCount}",
ranEndPoint.ComAddr, successCount, totalCount);
}
else
{
_logger.LogWarning("部分端口发送功率设置失败,地址: {ComAddr}, 成功数量: {SuccessCount}/{TotalCount}",
ranEndPoint.ComAddr, successCount, totalCount);
}
return allSuccess;
}
catch (Exception ex)
{
_logger.LogError(ex, "批量设置发送功率时发生异常,地址: {ComAddr}", ranEndPoint.ComAddr);
return false;
}
}
/// <summary>
/// 设置接收功率
/// </summary>
/// <param name="ranEndPoint">RAN 端点信息</param>
/// <param name="powerSettings">功率设置字典,key为端口号(int),value为功率值(double)</param>
/// <returns>是否成功设置功率</returns>
public async Task<bool> SetRxPowerAsync(RanIPEndPoint ranEndPoint, Dictionary<int, double> powerSettings)
{
if (!ValidateRanEndPoint(ranEndPoint))
{
_logger.LogWarning("RAN 端点未配置");
return false;
}
if (powerSettings == null || powerSettings.Count == 0)
{
_logger.LogWarning("功率设置字典为空或无效");
return false;
}
try
{
var successCount = 0;
var totalCount = powerSettings.Count;
_logger.LogInformation("开始批量设置接收功率,地址: {ComAddr}, 端口数量: {PortCount}", ranEndPoint.ComAddr, totalCount);
foreach (var setting in powerSettings)
{
var port = setting.Key;
var setPower = setting.Value;
var cmd_setPower = $"{BuildCommandPrefix(ranEndPoint)} '{{""message"":""rf"",""rx_power"":{setPower},""rx_channel_index"":{port}}}'";
_logger.LogDebug("设置端口 {Port} 的接收功率值为 {SetPower}", port, setPower);
var result = await ExecuteCommandAsync(cmd_setPower, "接收功率设置");
if (result.IsSuccess)
{
successCount++;
_logger.LogDebug("端口 {Port} 接收功率设置成功,功率值: {SetPower}", port, setPower);
}
else
{
_logger.LogWarning("端口 {Port} 接收功率设置失败,功率值: {SetPower}, 错误: {Error}",
port, setPower, result.Error);
}
}
var allSuccess = successCount == totalCount;
if (allSuccess)
{
_logger.LogInformation("所有端口接收功率设置成功,地址: {ComAddr}, 成功数量: {SuccessCount}/{TotalCount}",
ranEndPoint.ComAddr, successCount, totalCount);
}
else
{
_logger.LogWarning("部分端口接收功率设置失败,地址: {ComAddr}, 成功数量: {SuccessCount}/{TotalCount}",
ranEndPoint.ComAddr, successCount, totalCount);
}
return allSuccess;
}
catch (Exception ex)
{
_logger.LogError(ex, "批量设置接收功率时发生异常,地址: {ComAddr}", ranEndPoint.ComAddr);
return false;
}
}
/// <summary>
/// 设置所有端口的发送功率
/// </summary>
/// <param name="ranEndPoint">RAN 端点信息</param>
/// <param name="powerValues">所有端口的功率值数组,按端口顺序排列</param>
/// <returns>是否成功设置功率</returns>
public async Task<bool> SetAllTxPowerAsync(RanIPEndPoint ranEndPoint, double[] powerValues)
{
if (!ValidateRanEndPoint(ranEndPoint))
{
_logger.LogWarning("RAN 端点未配置");
return false;
}
if (powerValues == null || powerValues.Length == 0)
{
_logger.LogWarning("功率值数组为空或无效");
return false;
}
try
{
var powerArrayJson = $"[{string.Join(",", powerValues)}]";
var cmd_setAllPower = $"{BuildCommandPrefix(ranEndPoint)} '{{""message"":""rf"",""tx_power"":{powerArrayJson}}}'";
_logger.LogInformation("开始设置所有端口发送功率,地址: {ComAddr}, 端口数量: {PortCount}, 功率值: {PowerValues}",
ranEndPoint.ComAddr, powerValues.Length, string.Join(",", powerValues));
var result = await ExecuteCommandAsync(cmd_setAllPower, "所有端口发送功率设置");
if (result.IsSuccess)
{
_logger.LogInformation("所有端口发送功率设置成功,地址: {ComAddr}, 端口数量: {PortCount}",
ranEndPoint.ComAddr, powerValues.Length);
return true;
}
else
{
_logger.LogWarning("所有端口发送功率设置失败,地址: {ComAddr}, 端口数量: {PortCount}, 错误: {Error}",
ranEndPoint.ComAddr, powerValues.Length, result.Error);
return false;
}
}
catch (Exception ex)
{
_logger.LogError(ex, "设置所有端口发送功率时发生异常,地址: {ComAddr}, 端口数量: {PortCount}",
ranEndPoint.ComAddr, powerValues?.Length ?? 0);
return false;
}
}
/// <summary>
/// 设置所有端口的接收功率
/// </summary>
/// <param name="ranEndPoint">RAN 端点信息</param>
/// <param name="powerValues">所有端口的功率值数组,按端口顺序排列</param>
/// <returns>是否成功设置功率</returns>
public async Task<bool> SetAllRxPowerAsync(RanIPEndPoint ranEndPoint, double[] powerValues)
{
if (!ValidateRanEndPoint(ranEndPoint))
{
_logger.LogWarning("RAN 端点未配置");
return false;
}
if (powerValues == null || powerValues.Length == 0)
{
_logger.LogWarning("功率值数组为空或无效");
return false;
}
try
{
var powerArrayJson = $"[{string.Join(",", powerValues)}]";
var cmd_setAllPower = $"{BuildCommandPrefix(ranEndPoint)} '{{""message"":""rf"",""rx_power"":{powerArrayJson}}}'";
_logger.LogInformation("开始设置所有端口接收功率,地址: {ComAddr}, 端口数量: {PortCount}, 功率值: {PowerValues}",
ranEndPoint.ComAddr, powerValues.Length, string.Join(",", powerValues));
var result = await ExecuteCommandAsync(cmd_setAllPower, "所有端口接收功率设置");
if (result.IsSuccess)
{
_logger.LogInformation("所有端口接收功率设置成功,地址: {ComAddr}, 端口数量: {PortCount}",
ranEndPoint.ComAddr, powerValues.Length);
return true;
}
else
{
_logger.LogWarning("所有端口接收功率设置失败,地址: {ComAddr}, 端口数量: {PortCount}, 错误: {Error}",
ranEndPoint.ComAddr, powerValues.Length, result.Error);
return false;
}
}
catch (Exception ex)
{
_logger.LogError(ex, "设置所有端口接收功率时发生异常,地址: {ComAddr}, 端口数量: {PortCount}",
ranEndPoint.ComAddr, powerValues?.Length ?? 0);
return false;
}
}
#endregion
#region 增益控制方法
/// <summary>
/// 设置发送增益
/// </summary>
/// <param name="ranEndPoint">RAN 端点信息</param>
/// <param name="gainSettings">增益设置字典,key为端口号(int),value为增益值(double)</param>
/// <returns>是否成功设置增益</returns>
public async Task<bool> SetTxGainAsync(RanIPEndPoint ranEndPoint, Dictionary<int, double> gainSettings)
{
if (!ValidateRanEndPoint(ranEndPoint))
{
_logger.LogWarning("RAN 端点未配置");
return false;
}
if (gainSettings == null || gainSettings.Count == 0)
{
_logger.LogWarning("增益设置字典为空或无效");
return false;
}
try
{
var successCount = 0;
var totalCount = gainSettings.Count;
_logger.LogInformation("开始批量设置发送增益,地址: {ComAddr}, 端口数量: {PortCount}", ranEndPoint.ComAddr, totalCount);
foreach (var setting in gainSettings)
{
var port = setting.Key;
var setGain = setting.Value;
var cmd_setGain = $"{BuildCommandPrefix(ranEndPoint)} '{{""message"":""rf"",""tx_gain"":{setGain},""tx_channel_index"":{port}}}'";
_logger.LogDebug("设置端口 {Port} 的发送增益值为 {SetGain}", port, setGain);
var result = await ExecuteCommandAsync(cmd_setGain, "发送增益设置");
if (result.IsSuccess)
{
successCount++;
_logger.LogDebug("端口 {Port} 发送增益设置成功,增益值: {SetGain}", port, setGain);
}
else
{
_logger.LogWarning("端口 {Port} 发送增益设置失败,增益值: {SetGain}, 错误: {Error}",
port, setGain, result.Error);
}
}
var allSuccess = successCount == totalCount;
if (allSuccess)
{
_logger.LogInformation("所有端口发送增益设置成功,地址: {ComAddr}, 成功数量: {SuccessCount}/{TotalCount}",
ranEndPoint.ComAddr, successCount, totalCount);
}
else
{
_logger.LogWarning("部分端口发送增益设置失败,地址: {ComAddr}, 成功数量: {SuccessCount}/{TotalCount}",
ranEndPoint.ComAddr, successCount, totalCount);
}
return allSuccess;
}
catch (Exception ex)
{
_logger.LogError(ex, "批量设置发送增益时发生异常,地址: {ComAddr}", ranEndPoint.ComAddr);
return false;
}
}
/// <summary>
/// 设置接收增益
/// </summary>
/// <param name="ranEndPoint">RAN 端点信息</param>
/// <param name="gainSettings">增益设置字典,key为端口号(int),value为增益值(double)</param>
/// <returns>是否成功设置增益</returns>
public async Task<bool> SetRxGainAsync(RanIPEndPoint ranEndPoint, Dictionary<int, double> gainSettings)
{
if (!ValidateRanEndPoint(ranEndPoint))
{
_logger.LogWarning("RAN 端点未配置");
return false;
}
if (gainSettings == null || gainSettings.Count == 0)
{
_logger.LogWarning("增益设置字典为空或无效");
return false;
}
try
{
var successCount = 0;
var totalCount = gainSettings.Count;
_logger.LogInformation("开始批量设置接收增益,地址: {ComAddr}, 端口数量: {PortCount}", ranEndPoint.ComAddr, totalCount);
foreach (var setting in gainSettings)
{
var port = setting.Key;
var setGain = setting.Value;
var cmd_setGain = $"{BuildCommandPrefix(ranEndPoint)} '{{""message"":""rf"",""rx_gain"":{setGain},""rx_channel_index"":{port}}}'";
_logger.LogDebug("设置端口 {Port} 的接收增益值为 {SetGain}", port, setGain);
var result = await ExecuteCommandAsync(cmd_setGain, "接收增益设置");
if (result.IsSuccess)
{
successCount++;
_logger.LogDebug("端口 {Port} 接收增益设置成功,增益值: {SetGain}", port, setGain);
}
else
{
_logger.LogWarning("端口 {Port} 接收增益设置失败,增益值: {SetGain}, 错误: {Error}",
port, setGain, result.Error);
}
}
var allSuccess = successCount == totalCount;
if (allSuccess)
{
_logger.LogInformation("所有端口接收增益设置成功,地址: {ComAddr}, 成功数量: {SuccessCount}/{TotalCount}",
ranEndPoint.ComAddr, successCount, totalCount);
}
else
{
_logger.LogWarning("部分端口接收增益设置失败,地址: {ComAddr}, 成功数量: {SuccessCount}/{TotalCount}",
ranEndPoint.ComAddr, successCount, totalCount);
}
return allSuccess;
}
catch (Exception ex)
{
_logger.LogError(ex, "批量设置接收增益时发生异常,地址: {ComAddr}", ranEndPoint.ComAddr);
return false;
}
}
/// <summary>
/// 设置所有端口的发送增益
/// </summary>
/// <param name="ranEndPoint">RAN 端点信息</param>
/// <param name="gainValues">所有端口的增益值数组,按端口顺序排列</param>
/// <returns>是否成功设置增益</returns>
public async Task<bool> SetAllTxGainAsync(RanIPEndPoint ranEndPoint, double[] gainValues)
{
if (!ValidateRanEndPoint(ranEndPoint))
{
_logger.LogWarning("RAN 端点未配置");
return false;
}
if (gainValues == null || gainValues.Length == 0)
{
_logger.LogWarning("增益值数组为空或无效");
return false;
}
try
{
var gainArrayJson = $"[{string.Join(",", gainValues)}]";
var cmd_setAllGain = $"{BuildCommandPrefix(ranEndPoint)} '{{""message"":""rf"",""tx_gain"":{gainArrayJson}}}'";
_logger.LogInformation("开始设置所有端口发送增益,地址: {ComAddr}, 端口数量: {PortCount}, 增益值: {GainValues}",
ranEndPoint.ComAddr, gainValues.Length, string.Join(",", gainValues));
var result = await ExecuteCommandAsync(cmd_setAllGain, "所有端口发送增益设置");
if (result.IsSuccess)
{
_logger.LogInformation("所有端口发送增益设置成功,地址: {ComAddr}, 端口数量: {PortCount}",
ranEndPoint.ComAddr, gainValues.Length);
return true;
}
else
{
_logger.LogWarning("所有端口发送增益设置失败,地址: {ComAddr}, 端口数量: {PortCount}, 错误: {Error}",
ranEndPoint.ComAddr, gainValues.Length, result.Error);
return false;
}
}
catch (Exception ex)
{
_logger.LogError(ex, "设置所有端口发送增益时发生异常,地址: {ComAddr}, 端口数量: {PortCount}",
ranEndPoint.ComAddr, gainValues?.Length ?? 0);
return false;
}
}
/// <summary>
/// 设置所有端口的接收增益
/// </summary>
/// <param name="ranEndPoint">RAN 端点信息</param>
/// <param name="gainValues">所有端口的增益值数组,按端口顺序排列</param>
/// <returns>是否成功设置增益</returns>
public async Task<bool> SetAllRxGainAsync(RanIPEndPoint ranEndPoint, double[] gainValues)
{
if (!ValidateRanEndPoint(ranEndPoint))
{
_logger.LogWarning("RAN 端点未配置");
return false;
}
if (gainValues == null || gainValues.Length == 0)
{
_logger.LogWarning("增益值数组为空或无效");
return false;
}
try
{
var gainArrayJson = $"[{string.Join(",", gainValues)}]";
var cmd_setAllGain = $"{BuildCommandPrefix(ranEndPoint)} '{{""message"":""rf"",""rx_gain"":{gainArrayJson}}}'";
_logger.LogInformation("开始设置所有端口接收增益,地址: {ComAddr}, 端口数量: {PortCount}, 增益值: {GainValues}",
ranEndPoint.ComAddr, gainValues.Length, string.Join(",", gainValues));
var result = await ExecuteCommandAsync(cmd_setAllGain, "所有端口接收增益设置");
if (result.IsSuccess)
{
_logger.LogInformation("所有端口接收增益设置成功,地址: {ComAddr}, 端口数量: {PortCount}",
ranEndPoint.ComAddr, gainValues.Length);
return true;
}
else
{
_logger.LogWarning("所有端口接收增益设置失败,地址: {ComAddr}, 端口数量: {PortCount}, 错误: {Error}",
ranEndPoint.ComAddr, gainValues.Length, result.Error);
return false;
}
}
catch (Exception ex)
{
_logger.LogError(ex, "设置所有端口接收增益时发生异常,地址: {ComAddr}, 端口数量: {PortCount}",
ranEndPoint.ComAddr, gainValues?.Length ?? 0);
return false;
}
}
#endregion
}

2
CoreAgent.ProtocolClient/Models/ProtocolClientConfig.cs

@ -79,6 +79,8 @@ namespace CoreAgent.ProtocolClient.Models
/// 是否启用控制信道日志
/// </summary>
public bool? Cch { get; set; }
public bool? Bcch { get; set; }
}

6545
modify.md

File diff suppressed because it is too large
Loading…
Cancel
Save