smart_charging.hpp

// SPDX-License-Identifier: Apache-2.0
// Copyright Pionix GmbH and Contributors to EVerest
 
#pragma once
 
#include <ocpp/v2/message_handler.hpp>
 
#include <ocpp/v2/evse.hpp>
 
namespace ocpp::v2 {
struct FunctionalBlockContext;
class SmartChargingHandlerInterface;
 
struct GetChargingProfilesRequest;
struct SetChargingProfileRequest;
struct SetChargingProfileResponse;
struct GetCompositeScheduleResponse;
struct GetCompositeScheduleRequest;
struct ClearChargingProfileResponse;
struct ClearChargingProfileRequest;
struct ReportChargingProfilesRequest;
 
enum class ProfileValidationResultEnum {
    Valid,
    EvseDoesNotExist,
    ExistingChargingStationExternalConstraints,
    InvalidProfileType,
    TxProfileMissingTransactionId,
    TxProfileEvseIdNotGreaterThanZero,
    TxProfileTransactionNotOnEvse,
    TxProfileEvseHasNoActiveTransaction,
    TxProfileConflictingStackLevel,
    ChargingProfileNoChargingSchedulePeriods,
    ChargingProfileFirstStartScheduleIsNotZero,
    ChargingProfileMissingRequiredStartSchedule,
    ChargingProfileExtraneousStartSchedule,
    ChargingScheduleChargingRateUnitUnsupported,
    ChargingSchedulePeriodsOutOfOrder,
    ChargingSchedulePeriodInvalidPhaseToUse,
    ChargingSchedulePeriodUnsupportedNumberPhases,
    ChargingSchedulePeriodExtraneousPhaseValues,
    ChargingSchedulePeriodPhaseToUseACPhaseSwitchingUnsupported,
    ChargingStationMaxProfileCannotBeRelative,
    ChargingStationMaxProfileEvseIdGreaterThanZero,
    DuplicateTxDefaultProfileFound,
    DuplicateProfileValidityPeriod,
    RequestStartTransactionNonTxProfile,
    ChargingProfileEmptyChargingSchedules
};
 
enum class AddChargingProfileSource {
    SetChargingProfile,
    RequestStartTransactionRequest
};
 
namespace conversions {
std::string profile_validation_result_to_string(ProfileValidationResultEnum e);
 
std::string profile_validation_result_to_reason_code(ProfileValidationResultEnum e);
} // namespace conversions
 
std::ostream& operator<<(std::ostream& os, const ProfileValidationResultEnum validation_result);
 
class SmartChargingInterface : public MessageHandlerInterface {
public:
    virtual ~SmartChargingInterface() = default;
 
    virtual std::vector<CompositeSchedule> get_all_composite_schedules(const int32_t duration,
                                                                       const ChargingRateUnitEnum& unit) = 0;
 
    virtual void delete_transaction_tx_profiles(const std::string& transaction_id) = 0;
 
    virtual SetChargingProfileResponse conform_validate_and_add_profile(
        ChargingProfile& profile, int32_t evse_id,
        ChargingLimitSourceEnum charging_limit_source = ChargingLimitSourceEnum::CSO,
        AddChargingProfileSource source_of_request = AddChargingProfileSource::SetChargingProfile) = 0;
 
    virtual ProfileValidationResultEnum conform_and_validate_profile(
        ChargingProfile& profile, int32_t evse_id,
        AddChargingProfileSource source_of_request = AddChargingProfileSource::SetChargingProfile) = 0;
 
    virtual GetCompositeScheduleResponse get_composite_schedule(const GetCompositeScheduleRequest& request) = 0;
 
    virtual std::optional<CompositeSchedule> get_composite_schedule(int32_t evse_id, std::chrono::seconds duration,
                                                                    ChargingRateUnitEnum unit) = 0;
};
 
class SmartCharging : public SmartChargingInterface {
private: // Members
    const FunctionalBlockContext& context;
    std::function<void()> set_charging_profiles_callback;
 
public:
    SmartCharging(const FunctionalBlockContext& functional_block_context,
                  std::function<void()> set_charging_profiles_callback);
    void handle_message(const ocpp::EnhancedMessage<MessageType>& message) override;
    GetCompositeScheduleResponse get_composite_schedule(const GetCompositeScheduleRequest& request) override;
    std::optional<CompositeSchedule> get_composite_schedule(int32_t evse_id, std::chrono::seconds duration,
                                                            ChargingRateUnitEnum unit) override;
    std::vector<CompositeSchedule> get_all_composite_schedules(const int32_t duration,
                                                               const ChargingRateUnitEnum& unit) override;
 
    void delete_transaction_tx_profiles(const std::string& transaction_id) override;
 
    SetChargingProfileResponse conform_validate_and_add_profile(
        ChargingProfile& profile, int32_t evse_id,
        ChargingLimitSourceEnum charging_limit_source = ChargingLimitSourceEnum::CSO,
        AddChargingProfileSource source_of_request = AddChargingProfileSource::SetChargingProfile) override;
    ProfileValidationResultEnum conform_and_validate_profile(
        ChargingProfile& profile, int32_t evse_id,
        AddChargingProfileSource source_of_request = AddChargingProfileSource::SetChargingProfile) override;
 
protected:
    CompositeSchedule calculate_composite_schedule(const ocpp::DateTime& start_time, const ocpp::DateTime& end_time,
                                                   const int32_t evse_id, ChargingRateUnitEnum charging_rate_unit,
                                                   bool is_offline, bool simulate_transaction_active);
 
    ProfileValidationResultEnum validate_evse_exists(int32_t evse_id) const;
 
    ProfileValidationResultEnum validate_charging_station_max_profile(const ChargingProfile& profile,
                                                                      int32_t evse_id) const;
 
    ProfileValidationResultEnum validate_tx_default_profile(const ChargingProfile& profile, int32_t evse_id) const;
 
    ProfileValidationResultEnum validate_tx_profile(
        const ChargingProfile& profile, int32_t evse_id,
        AddChargingProfileSource source_of_request = AddChargingProfileSource::SetChargingProfile) const;
 
    ProfileValidationResultEnum validate_profile_schedules(ChargingProfile& profile,
                                                           std::optional<EvseInterface*> evse_opt = std::nullopt) const;
 
    ProfileValidationResultEnum verify_no_conflicting_external_constraints_id(const ChargingProfile& profile) const;
 
    SetChargingProfileResponse
    add_profile(ChargingProfile& profile, int32_t evse_id,
                ChargingLimitSourceEnum charging_limit_source = ChargingLimitSourceEnum::CSO);
 
    ClearChargingProfileResponse clear_profiles(const ClearChargingProfileRequest& request);
 
    std::vector<ReportedChargingProfile> get_reported_profiles(const GetChargingProfilesRequest& request) const;
 
    std::vector<ChargingProfile>
    get_valid_profiles(int32_t evse_id, const std::vector<ChargingProfilePurposeEnum>& purposes_to_ignore = {});
 
private: // Functions
    /* OCPP message requests */
    void report_charging_profile_req(const int32_t request_id, const int32_t evse_id,
                                     const ChargingLimitSourceEnum source, const std::vector<ChargingProfile>& profiles,
                                     const bool tbc);
    void report_charging_profile_req(const ReportChargingProfilesRequest& req);
 
    /* OCPP message handlers */
    void handle_set_charging_profile_req(Call<SetChargingProfileRequest> call);
    void handle_clear_charging_profile_req(Call<ClearChargingProfileRequest> call);
    void handle_get_charging_profiles_req(Call<GetChargingProfilesRequest> call);
    void handle_get_composite_schedule_req(Call<GetCompositeScheduleRequest> call);
 
    GetCompositeScheduleResponse get_composite_schedule_internal(const GetCompositeScheduleRequest& request,
                                                                 bool simulate_transaction_active = true);
 
    ProfileValidationResultEnum validate_request_start_transaction_profile(const ChargingProfile& profile) const;
 
    bool is_overlapping_validity_period(const ChargingProfile& candidate_profile, int32_t candidate_evse_id) const;
 
    std::vector<ChargingProfile> get_evse_specific_tx_default_profiles() const;
    std::vector<ChargingProfile> get_station_wide_tx_default_profiles() const;
    std::vector<ChargingProfile>
    get_valid_profiles_for_evse(int32_t evse_id,
                                const std::vector<ChargingProfilePurposeEnum>& purposes_to_ignore = {});
    void conform_schedule_number_phases(int32_t profile_id, ChargingSchedulePeriod& charging_schedule_period) const;
    void conform_validity_periods(ChargingProfile& profile) const;
    CurrentPhaseType get_current_phase_type(const std::optional<EvseInterface*> evse_opt) const;
};
} // namespace ocpp::v2