AIDT 온디바이스 국방 MUM-T 성층권 고고도 장기체공(HALE) 태양광 무인기 다채널 분산 MPPT 및 전력 분배 서보 엔진

using System;
using System.Runtime.CompilerServices;

namespace ZeliDesk.Defense.MumT.HaleUav
{
    /// <summary>
    /// 단일 태양광 모듈 스트링 계측 상태
    /// </summary>
    public readonly struct HalePvStringTelemetry
    {
        public readonly double Voltage;    // 스트링 전압 [V]
        public readonly double Current;    // 스트링 전류 [A]
        public readonly double TempCelsius;// 패널 표면 온도 [degC]

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public HalePvStringTelemetry(double v, double i, double temp)
        {
            Voltage = v;
            Current = i;
            TempCelsius = temp;
        }
    }

    /// <summary>
    /// HALE 통합 전력 관리 및 MPPT 지령 출력
    /// </summary>
    public readonly ref struct HalePowerManagementOutput
    {
        public readonly double TotalSolarPowerWatts;  // 전체 수확 태양광 전력 [W]
        public readonly double BatteryNetCurrentAmps; // 배터리 충·방전 전류 (+:충전, -:방전) [A]
        public readonly double CurrentSocRatePerSec;  // 초당 SOC 변화율
        public readonly bool IsDayEnergySurplus;      // 주간 잉여 전력 축적 모드 여부

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public HalePowerManagementOutput(double totalP, double iBat, double dSoc, bool surplus)
        {
            TotalSolarPowerWatts = totalP;
            BatteryNetCurrentAmps = iBat;
            CurrentSocRatePerSec = dSoc;
            IsDayEnergySurplus = surplus;
        }
    }

    /// <summary>
    /// 10,000Hz 다채널 분산 MPPT 및 전력 분배 서보 엔진
    /// </summary>
    public ref struct HaleDistributedMpptServoEngine
    {
        private readonly double _voltageStep;
        private readonly double _busVoltage;
        private readonly double _batteryCapacityAh;
        private readonly double _batteryEfficiency;

        // 채널별 직전 전압 및 전력 이력 버퍼
        private readonly Span<double> _prevVoltages;
        private readonly Span<double> _prevPowers;
        private readonly Span<double> _mpptVoltTargets;

        public HaleDistributedMpptServoEngine(
            double voltageStep,
            double busVoltage,
            double batteryCapacityAh,
            double batteryEfficiency,
            Span<double> prevV,
            Span<double> prevP,
            Span<double> targetV)
        {
            _voltageStep = voltageStep;
            _busVoltage = busVoltage;
            _batteryCapacityAh = batteryCapacityAh;
            _batteryEfficiency = batteryEfficiency;
            _prevVoltages = prevV;
            _prevPowers = prevP;
            _mpptVoltTargets = targetV;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public HalePowerManagementOutput ProcessCycle(
            ReadOnlySpan<HalePvStringTelemetry> telemetry,
            double loadPowerWatts)
        {
            double totalHarvestedWatts = 0.0;
            int count = telemetry.Length;

            for (int i = 0; i < count; i++)
            {
                ref readonly var str = ref telemetry[i];
                double pNow = str.Voltage * str.Current;
                totalHarvestedWatts += pNow;

                double dP = pNow - _prevPowers[i];
                double dV = str.Voltage - _prevVoltages[i];

                double step = _voltageStep;
                if (Math.Abs(dV) > 1e-4)
                {
                    double slope = dP / dV;
                    if (slope > 0)
                    {
                        _mpptVoltTargets[i] += step;
                    }
                    else if (slope < 0)
                    {
                        _mpptVoltTargets[i] -= step;
                    }
                }
                else
                {
                    _mpptVoltTargets[i] += step;
                }

                _prevVoltages[i] = str.Voltage;
                _prevPowers[i] = pNow;
            }

            // 전체 전력 밸런스 및 배터리 충·방전 전류
            double netWatts = totalHarvestedWatts - loadPowerWatts;
            double netCurrentAmps = netWatts / _busVoltage;

            if (netCurrentAmps > 0)
            {
                netCurrentAmps *= _batteryEfficiency; // 충전 효율 적용
            }
            else
            {
                netCurrentAmps /= _batteryEfficiency; // 방전 손실 반영
            }

            // 초당 SOC 변화율 = netCurrentAmps / (3600 * CapacityAh)
            double dSocPerSec = netCurrentAmps / (3600.0 * _batteryCapacityAh);
            bool isSurplus = netWatts > 0.0;

            return new HalePowerManagementOutput(
                totalHarvestedWatts,
                netCurrentAmps,
                dSocPerSec,
                isSurplus);
        }
    }
}