charge_point.hpp

// SPDX-License-Identifier: Apache-2.0
// Copyright 2020 - 2023 Pionix GmbH and Contributors to EVerest
#ifndef OCPP_V16_CHARGE_POINT_HPP
#define OCPP_V16_CHARGE_POINT_HPP
 
#include <ocpp/common/cistring.hpp>
#include <ocpp/common/evse_security.hpp>
#include <ocpp/common/evse_security_impl.hpp>
#include <ocpp/common/support_older_cpp_versions.hpp>
#include <ocpp/v16/charge_point_state_machine.hpp>
#include <ocpp/v16/ocpp_types.hpp>
#include <ocpp/v16/smart_charging.hpp>
#include <ocpp/v16/types.hpp>
 
#include <ocpp/v16/messages/BootNotification.hpp>
#include <ocpp/v16/messages/DataTransfer.hpp>
#include <ocpp/v16/messages/GetConfiguration.hpp>
#include <ocpp/v16/messages/GetDiagnostics.hpp>
#include <ocpp/v16/messages/GetLog.hpp>
#include <ocpp/v16/messages/SignedUpdateFirmware.hpp>
#include <ocpp/v16/messages/UpdateFirmware.hpp>
 
// for OCPP1.6 PnC
#include "ocpp/v16/messages/ChangeAvailability.hpp"
#include <ocpp/v2/messages/Authorize.hpp>
#include <ocpp/v2/messages/CertificateSigned.hpp>
#include <ocpp/v2/messages/DeleteCertificate.hpp>
#include <ocpp/v2/messages/Get15118EVCertificate.hpp>
#include <ocpp/v2/messages/GetCertificateStatus.hpp>
#include <ocpp/v2/messages/GetInstalledCertificateIds.hpp>
#include <ocpp/v2/messages/InstallCertificate.hpp>
#include <ocpp/v2/messages/SignCertificate.hpp>
#include <ocpp/v2/messages/TriggerMessage.hpp>
 
namespace ocpp {
namespace v16 {
class ChargePointImpl;
 
class ChargePoint {
private:
    std::unique_ptr<ChargePointImpl> charge_point;
 
 
 
public:
    explicit ChargePoint(const std::string& config, const fs::path& share_path, const fs::path& user_config_path,
                         const fs::path& database_path, const fs::path& sql_init_path, const fs::path& message_log_path,
                         const std::shared_ptr<EvseSecurity> evse_security,
                         const std::optional<SecurityConfiguration> security_configuration = std::nullopt);
 
    ~ChargePoint();
 
 
    bool start(const std::map<int, ChargePointStatus>& connector_status_map = {},
               BootReasonEnum bootreason = BootReasonEnum::PowerUp,
               const std::set<std::string>& resuming_session_ids = {});
 
    bool restart(const std::map<int, ChargePointStatus>& connector_status_map = {},
                 BootReasonEnum bootreason = BootReasonEnum::ApplicationReset);
 
    // \brief Resets the internal state machine for the connectors using the given \p connector_status_map
    void reset_state_machine(const std::map<int, ChargePointStatus>& connector_status_map);
 
    bool stop();
 
    void connect_websocket();
 
    void disconnect_websocket();
 
    void call_set_connection_timeout();
 
    // public API for Core profile
 
    IdTagInfo authorize_id_token(CiString<20> id_token);
 
    // for plug&charge 1.6 whitepaper
 
    ocpp::v2::AuthorizeResponse data_transfer_pnc_authorize(
        const std::string& emaid, const std::optional<std::string>& certificate,
        const std::optional<std::vector<ocpp::v2::OCSPRequestData>>& iso15118_certificate_hash_data);
 
    void data_transfer_pnc_get_15118_ev_certificate(const int32_t connector_id, const std::string& exi_request,
                                                    const std::string& iso15118_schema_version,
                                                    const ocpp::v2::CertificateActionEnum& certificate_action);
 
    std::optional<DataTransferResponse> data_transfer(const CiString<255>& vendorId,
                                                      const std::optional<CiString<50>>& messageId,
                                                      const std::optional<std::string>& data);
 
    std::map<int32_t, ChargingSchedule>
    get_all_composite_charging_schedules(const int32_t duration_s, const ChargingRateUnit unit = ChargingRateUnit::A);
 
    std::map<int32_t, EnhancedChargingSchedule>
    get_all_enhanced_composite_charging_schedules(const int32_t duration_s,
                                                  const ChargingRateUnit unit = ChargingRateUnit::A);
 
 
 
    void on_meter_values(int32_t connector, const Measurement& measurement);
 
    void on_max_current_offered(int32_t connector, int32_t max_current);
 
    void on_max_power_offered(int32_t connector, int32_t max_power);
 
    void on_session_started(int32_t connector, const std::string& session_id, const SessionStartedReason reason,
                            const std::optional<std::string>& session_logging_path);
 
    void on_session_stopped(int32_t connector, const std::string& session_id);
 
    void on_transaction_started(const int32_t& connector, const std::string& session_id, const std::string& id_token,
                                const double meter_start, std::optional<int32_t> reservation_id,
                                const ocpp::DateTime& timestamp, std::optional<std::string> signed_meter_value);
 
    void on_transaction_stopped(const int32_t connector, const std::string& session_id, const Reason& reason,
                                ocpp::DateTime timestamp, float energy_wh_import,
                                std::optional<CiString<20>> id_tag_end, std::optional<std::string> signed_meter_value);
 
    void on_suspend_charging_ev(int32_t connector, const std::optional<CiString<50>> info = std::nullopt);
 
    void on_suspend_charging_evse(int32_t connector, const std::optional<CiString<50>> info = std::nullopt);
 
    void on_resume_charging(int32_t connector);
 
    void on_error(int32_t connector, const ErrorInfo& error_info);
 
    void on_error_cleared(int32_t connector, const std::string uuid);
 
    void on_all_errors_cleared(int32_t connector);
 
    void on_log_status_notification(int32_t request_id, std::string log_status);
 
    void on_firmware_update_status_notification(int32_t request_id,
                                                const ocpp::FirmwareStatusNotification firmware_update_status);
 
    void on_reservation_start(int32_t connector);
 
    void on_reservation_end(int32_t connector);
 
    void on_enabled(int32_t connector);
 
    void on_disabled(int32_t connector);
 
    void on_plugin_timeout(int32_t connector);
 
    void on_security_event(const CiString<50>& event_type, const std::optional<CiString<255>>& tech_info,
                           const std::optional<bool>& critical = std::nullopt,
                           const std::optional<DateTime>& timestamp = std::nullopt);
 
    ChangeAvailabilityResponse on_change_availability(const ChangeAvailabilityRequest& request);
 
 
 
 
 
    void register_data_transfer_callback(
        const CiString<255>& vendorId, const CiString<50>& messageId,
        const std::function<DataTransferResponse(const std::optional<std::string>& msg)>& callback);
 
    void register_data_transfer_callback(
        const std::function<DataTransferResponse(const DataTransferRequest& request)>& callback);
 
    void register_enable_evse_callback(const std::function<bool(int32_t connector)>& callback);
 
    void register_disable_evse_callback(const std::function<bool(int32_t connector)>& callback);
 
    void register_pause_charging_callback(const std::function<bool(int32_t connector)>& callback);
 
    void register_resume_charging_callback(const std::function<bool(int32_t connector)>& callback);
 
    void register_provide_token_callback(
        const std::function<void(const std::string& id_token, std::vector<int32_t> referenced_connectors,
                                 bool prevalidated)>& callback);
 
    void register_stop_transaction_callback(const std::function<bool(int32_t connector, Reason reason)>& callback);
 
    void register_reserve_now_callback(
        const std::function<ReservationStatus(int32_t reservation_id, int32_t connector, ocpp::DateTime expiryDate,
                                              CiString<20> idTag, std::optional<CiString<20>> parent_id)>& callback);
 
    void register_cancel_reservation_callback(const std::function<bool(int32_t reservation_id)>& callback);
 
    // active at the specified connector, the \p callback shall stop the transaction before unlocking the connector. The
    // unlock_connector_callback is called:
    void register_unlock_connector_callback(const std::function<UnlockStatus(int32_t connector)>& callback);
 
    void register_upload_diagnostics_callback(
        const std::function<GetLogResponse(const GetDiagnosticsRequest& request)>& callback);
 
    void register_update_firmware_callback(const std::function<void(const UpdateFirmwareRequest msg)>& callback);
 
    void register_signed_update_firmware_callback(
        const std::function<UpdateFirmwareStatusEnumType(const SignedUpdateFirmwareRequest msg)>& callback);
 
    void register_all_connectors_unavailable_callback(const std::function<void()>& callback);
 
    void register_upload_logs_callback(const std::function<GetLogResponse(GetLogRequest req)>& callback);
 
    void register_set_connection_timeout_callback(const std::function<void(int32_t connection_timeout)>& callback);
 
    void register_is_reset_allowed_callback(const std::function<bool(const ResetType& reset_type)>& callback);
 
    void register_reset_callback(const std::function<void(const ResetType& reset_type)>& callback);
 
    void register_set_system_time_callback(const std::function<void(const std::string& system_time)>& callback);
 
    void register_boot_notification_response_callback(
        const std::function<void(const BootNotificationResponse& boot_notification_response)>& callback);
 
    void register_signal_set_charging_profiles_callback(const std::function<void()>& callback);
 
    void register_connection_state_changed_callback(const std::function<void(bool is_connected)>& callback);
 
    void register_get_15118_ev_certificate_response_callback(
        const std::function<void(const int32_t connector,
                                 const ocpp::v2::Get15118EVCertificateResponse& certificate_response,
                                 const ocpp::v2::CertificateActionEnum& certificate_action)>& callback);
 
    void register_transaction_started_callback(
        const std::function<void(const int32_t connector, const std::string& session_id)>& callback);
 
    void register_transaction_stopped_callback(
        const std::function<void(const int32_t connector, const std::string& session_id, const int32_t transaction_id)>&
            callback);
 
    void register_transaction_updated_callback(
        const std::function<void(const int32_t connector, const std::string& session_id, const int32_t transaction_id,
                                 const IdTagInfo& id_tag_info)>& callback);
 
    void register_configuration_key_changed_callback(const CiString<50>& key,
                                                     const std::function<void(const KeyValue& key_value)>& callback);
 
    void
    register_generic_configuration_key_changed_callback(const std::function<void(const KeyValue& key_value)>& callback);
 
    void register_security_event_callback(
        const std::function<void(const std::string& type, const std::string& tech_info)>& callback);
 
    void register_is_token_reserved_for_connector_callback(
        const std::function<ReservationCheckStatus(const int32_t connector, const std::string& id_token)>& callback);
 
    void register_session_cost_callback(
        const std::function<DataTransferResponse(const RunningCost& session_cost, const uint32_t number_of_decimals)>&
            session_cost_callback);
 
    void register_set_display_message_callback(
        const std::function<DataTransferResponse(const std::vector<DisplayMessage>&)> set_display_message_callback);
 
 
 
    GetConfigurationResponse get_configuration_key(const GetConfigurationRequest& request);
 
    ConfigurationStatus set_custom_configuration_key(CiString<50> key, CiString<500> value);
 
    void set_message_queue_resume_delay(std::chrono::seconds delay);
};
 
} // namespace v16
} // namespace ocpp
#endif