profile.hpp

// SPDX-License-Identifier: Apache-2.0
// Copyright 2020 - 2024 Pionix GmbH and Contributors to EVerest
 
#include <ocpp/v2/ocpp_types.hpp>
 
namespace ocpp {
namespace v2 {
 
struct IntermediatePeriod {
    int32_t startPeriod;
    float current_limit;
    float power_limit;
    std::optional<int32_t> numberPhases;
    std::optional<int32_t> phaseToUse;
};
 
using IntermediateProfile = std::vector<IntermediatePeriod>;
 
struct period_entry_t {
    void init(const ocpp::DateTime& in_start, int in_duration, const ChargingSchedulePeriod& in_period,
              const ChargingProfile& in_profile);
    bool validate(const ChargingProfile& profile, const ocpp::DateTime& now);
 
    ocpp::DateTime start;
    ocpp::DateTime end;
    float limit;
    std::optional<std::int32_t> number_phases;
    std::optional<std::int32_t> phase_to_use;
    std::int32_t stack_level;
    ChargingRateUnitEnum charging_rate_unit;
    std::optional<float> min_charging_rate;
 
    bool equals(const period_entry_t& other) const {
        return (start == other.end) && (end == other.end) && (limit == other.limit) &&
               (number_phases == other.number_phases) && (stack_level == other.stack_level) &&
               (charging_rate_unit == other.charging_rate_unit) && (min_charging_rate == other.min_charging_rate);
    }
};
 
int32_t elapsed_seconds(const ocpp::DateTime& to, const ocpp::DateTime& from);
 
ocpp::DateTime floor_seconds(const ocpp::DateTime& dt);
 
std::vector<DateTime> calculate_start(const DateTime& now, const DateTime& end,
                                      const std::optional<DateTime>& session_start, const ChargingProfile& profile);
 
std::vector<period_entry_t> calculate_profile_entry(const DateTime& now, const DateTime& end,
                                                    const std::optional<DateTime>& session_start,
                                                    const ChargingProfile& profile, std::uint8_t period_index);
 
std::vector<period_entry_t> calculate_profile(const DateTime& now, const DateTime& end,
                                              const std::optional<DateTime>& session_start,
                                              const ChargingProfile& profile);
 
std::vector<period_entry_t> calculate_all_profiles(const DateTime& now, const DateTime& end,
                                                   const std::optional<DateTime>& session_start,
                                                   const std::vector<ChargingProfile>& profiles,
                                                   ChargingProfilePurposeEnum purpose);
 
IntermediateProfile generate_profile_from_periods(std::vector<period_entry_t>& periods, const DateTime& now,
                                                  const DateTime& end);
 
IntermediateProfile merge_tx_profile_with_tx_default_profile(const IntermediateProfile& tx_profile,
                                                             const IntermediateProfile& tx_default_profile);
 
IntermediateProfile merge_profiles_by_lowest_limit(const std::vector<IntermediateProfile>& profiles);
 
IntermediateProfile merge_profiles_by_summing_limits(const std::vector<IntermediateProfile>& profiles,
                                                     float current_default, float power_default);
 
void fill_gaps_with_defaults(IntermediateProfile& schedule, float default_limit, int32_t default_number_phases);
 
std::vector<ChargingSchedulePeriod>
convert_intermediate_into_schedule(const IntermediateProfile& profile, ChargingRateUnitEnum charging_rate_unit,
                                   float default_limit, int32_t default_number_phases, float supply_voltage);
 
} // namespace v2
} // namespace ocpp