evse.hpp

// SPDX-License-Identifier: Apache-2.0
// Copyright 2020 - 2023 Pionix GmbH and Contributors to EVerest
 
#pragma once
 
#include <functional>
#include <map>
#include <memory>
 
#include <ocpp/v2/average_meter_values.hpp>
#include <ocpp/v2/component_state_manager.hpp>
#include <ocpp/v2/connector.hpp>
#include <ocpp/v2/database_handler.hpp>
#include <ocpp/v2/device_model.hpp>
#include <ocpp/v2/ocpp_types.hpp>
#include <ocpp/v2/transaction.hpp>
 
namespace ocpp {
namespace v2 {
 
enum class CurrentPhaseType {
    AC,
    DC,
    Unknown,
};
 
class EvseInterface {
public:
    virtual ~EvseInterface();
 
    virtual int32_t get_id() const = 0;
 
    virtual uint32_t get_number_of_connectors() const = 0;
 
    virtual bool does_connector_exist(ConnectorEnum connector_type) const = 0;
 
    virtual std::optional<ConnectorStatusEnum> get_connector_status(std::optional<ConnectorEnum> connector_type) = 0;
 
    virtual void open_transaction(const std::string& transaction_id, const int32_t connector_id,
                                  const DateTime& timestamp, const MeterValue& meter_start,
                                  const std::optional<IdToken>& id_token, const std::optional<IdToken>& group_id_token,
                                  const std::optional<int32_t> reservation_id,
                                  const ChargingStateEnum charging_state) = 0;
 
    virtual void close_transaction(const DateTime& timestamp, const MeterValue& meter_stop,
                                   const ReasonEnum& reason) = 0;
 
    virtual void start_checking_max_energy_on_invalid_id() = 0;
 
    virtual bool has_active_transaction() const = 0;
 
    virtual bool has_active_transaction(const int32_t connector_id) const = 0;
 
    virtual void release_transaction() = 0;
 
    virtual std::unique_ptr<EnhancedTransaction>& get_transaction() = 0;
 
    virtual void submit_event(const int32_t connector_id, ConnectorEvent event) = 0;
 
    virtual void on_meter_value(const MeterValue& meter_value) = 0;
 
    virtual MeterValue get_meter_value() = 0;
 
    virtual MeterValue get_idle_meter_value() = 0;
 
    virtual void clear_idle_meter_values() = 0;
 
    virtual Connector* get_connector(int32_t connector_id) const = 0;
 
    virtual OperationalStatusEnum get_effective_operational_status() = 0;
 
    virtual void set_evse_operative_status(OperationalStatusEnum new_status, bool persist) = 0;
 
    virtual void set_connector_operative_status(int32_t connector_id, OperationalStatusEnum new_status,
                                                bool persist) = 0;
 
    virtual void restore_connector_operative_status(int32_t connector_id) = 0;
 
    virtual OperationalStatusEnum get_connector_effective_operational_status(const int32_t connector_id) = 0;
 
    virtual CurrentPhaseType get_current_phase_type() = 0;
 
    virtual void set_meter_value_pricing_triggers(
        std::optional<double> trigger_metervalue_on_power_kw, std::optional<double> trigger_metervalue_on_energy_kwh,
        std::optional<DateTime> trigger_metervalue_at_time,
        std::function<void(const std::vector<MeterValue>& meter_values)> send_metervalue_function,
        boost::asio::io_service& io_service) = 0;
};
 
class Evse : public EvseInterface {
 
private:
    int32_t evse_id;
    DeviceModel& device_model;
    std::map<int32_t, std::unique_ptr<Connector>> id_connector_map;
    std::function<void(const MeterValue& meter_value, EnhancedTransaction& transaction)> transaction_meter_value_req;
    std::function<void(int32_t evse_id)> pause_charging_callback;
    std::unique_ptr<EnhancedTransaction> transaction; // pointer to active transaction (can be nullptr)
    MeterValue meter_value;                           // represents current meter value
    std::recursive_mutex meter_value_mutex;
    Everest::SteadyTimer sampled_meter_values_timer;
    std::shared_ptr<DatabaseHandler> database_handler;
 
    std::optional<double> trigger_metervalue_on_power_kw;
    std::optional<double> trigger_metervalue_on_energy_kwh;
    std::unique_ptr<Everest::SystemTimer> trigger_metervalue_at_time_timer;
    std::optional<double> last_triggered_metervalue_power_kw;
    std::function<void(const std::vector<MeterValue>& meter_values)> send_metervalue_function;
    boost::asio::io_service io_service;
 
    std::optional<float> get_active_import_register_meter_value();
 
    void check_max_energy_on_invalid_id();
 
    void start_metering_timers(const DateTime& timestamp);
 
    void send_meter_value_on_pricing_trigger(const MeterValue& meter_value);
 
    void reset_pricing_triggers(void);
 
    AverageMeterValues aligned_data_updated;
    AverageMeterValues aligned_data_tx_end;
 
    void try_resume_transaction();
 
    void delete_database_transaction();
 
    std::shared_ptr<ComponentStateManagerInterface> component_state_manager;
 
    std::optional<ConnectorEnum> get_evse_connector_type(const uint32_t connector_id) const;
 
public:
    Evse(const int32_t evse_id, const int32_t number_of_connectors, DeviceModel& device_model,
         std::shared_ptr<DatabaseHandler> database_handler,
         std::shared_ptr<ComponentStateManagerInterface> component_state_manager,
         const std::function<void(const MeterValue& meter_value, EnhancedTransaction& transaction)>&
             transaction_meter_value_req,
         const std::function<void(int32_t evse_id)>& pause_charging_callback);
 
    virtual ~Evse();
 
    int32_t get_id() const;
 
    uint32_t get_number_of_connectors() const;
    bool does_connector_exist(const ConnectorEnum connector_type) const override;
    std::optional<ConnectorStatusEnum> get_connector_status(std::optional<ConnectorEnum> connector_type) override;
 
    void open_transaction(const std::string& transaction_id, const int32_t connector_id, const DateTime& timestamp,
                          const MeterValue& meter_start, const std::optional<IdToken>& id_token,
                          const std::optional<IdToken>& group_id_token, const std::optional<int32_t> reservation_id,
                          const ChargingStateEnum charging_state);
    void close_transaction(const DateTime& timestamp, const MeterValue& meter_stop, const ReasonEnum& reason);
 
    void start_checking_max_energy_on_invalid_id();
 
    bool has_active_transaction() const;
    bool has_active_transaction(const int32_t connector_id) const;
    void release_transaction();
    std::unique_ptr<EnhancedTransaction>& get_transaction();
 
    void submit_event(const int32_t connector_id, ConnectorEvent event);
 
    void on_meter_value(const MeterValue& meter_value);
    MeterValue get_meter_value();
 
    MeterValue get_idle_meter_value();
    void clear_idle_meter_values();
 
    Connector* get_connector(int32_t connector_id) const;
 
    OperationalStatusEnum get_effective_operational_status();
    void set_evse_operative_status(OperationalStatusEnum new_status, bool persist);
    void set_connector_operative_status(int32_t connector_id, OperationalStatusEnum new_status, bool persist);
    void restore_connector_operative_status(int32_t connector_id);
    OperationalStatusEnum get_connector_effective_operational_status(const int32_t connector_id) override;
 
    CurrentPhaseType get_current_phase_type();
 
    void set_meter_value_pricing_triggers(
        std::optional<double> trigger_metervalue_on_power_kw, std::optional<double> trigger_metervalue_on_energy_kwh,
        std::optional<DateTime> trigger_metervalue_at_time,
        std::function<void(const std::vector<MeterValue>& meter_values)> send_metervalue_function,
        boost::asio::io_service& io_service);
};
 
} // namespace v2
} // namespace ocpp