availability.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/messages/ChangeAvailability.hpp>
 
namespace ocpp::v2 {
struct FunctionalBlockContext;
 
struct HeartbeatResponse;
 
struct AvailabilityChange {
    ChangeAvailabilityRequest request;
    bool persist;
};
 
class AvailabilityInterface : public MessageHandlerInterface {
public:
    virtual ~AvailabilityInterface() {
    }
 
    virtual void handle_message(const ocpp::EnhancedMessage<MessageType>& message) = 0;
 
    // Functional Block G: Availability OCPP requests.
    virtual void status_notification_req(const int32_t evse_id, const int32_t connector_id,
                                         const ConnectorStatusEnum status,
                                         const bool initiated_by_trigger_message = false) = 0;
 
    virtual void heartbeat_req(const bool initiated_by_trigger_message = false) = 0;
 
    virtual void handle_scheduled_change_availability_requests(const int32_t evse_id) = 0;
 
    virtual void set_scheduled_change_availability_requests(const int32_t evse_id,
                                                            AvailabilityChange availability_change) = 0;
 
    virtual void set_heartbeat_timer_interval(const std::chrono::seconds& interval) = 0;
 
    virtual void stop_heartbeat_timer() = 0;
};
 
typedef std::function<void(const ocpp::DateTime& currentTime)> TimeSyncCallback;
typedef std::function<void()> AllConnectorsUnavailableCallback;
 
class Availability : public AvailabilityInterface {
private: // Members
    const FunctionalBlockContext& context;
 
    std::optional<TimeSyncCallback> time_sync_callback;
    std::optional<AllConnectorsUnavailableCallback> all_connectors_unavailable_callback;
 
    std::chrono::time_point<std::chrono::steady_clock> heartbeat_request_time;
 
    std::map<int32_t, AvailabilityChange> scheduled_change_availability_requests;
    Everest::SteadyTimer heartbeat_timer;
 
public:
    Availability(const FunctionalBlockContext& functional_block_context,
                 std::optional<TimeSyncCallback> time_sync_callback,
                 std::optional<AllConnectorsUnavailableCallback> all_connectors_unavailable_callback);
    ~Availability();
    void handle_message(const ocpp::EnhancedMessage<MessageType>& message) override;
 
    // Functional Block G: Availability
    void status_notification_req(const int32_t evse_id, const int32_t connector_id, const ConnectorStatusEnum status,
                                 const bool initiated_by_trigger_message = false) override;
    void heartbeat_req(const bool initiated_by_trigger_message = false) override;
 
    void handle_scheduled_change_availability_requests(const int32_t evse_id) override;
    void set_scheduled_change_availability_requests(const int32_t evse_id,
                                                    AvailabilityChange availability_change) override;
 
    void set_heartbeat_timer_interval(const std::chrono::seconds& interval) override;
    void stop_heartbeat_timer() override;
 
private: // Functions
    // Functional Block G: Availability
 
    void handle_change_availability_req(Call<ChangeAvailabilityRequest> call);
 
    void handle_heartbeat_response(CallResult<HeartbeatResponse> call);
 
    bool is_already_in_state(const ChangeAvailabilityRequest& request);
 
    void execute_change_availability_request(ChangeAvailabilityRequest request, bool persist);
 
    void set_cs_operative_status(OperationalStatusEnum new_status, bool persist);
 
    void set_evse_operative_status(int32_t evse_id, OperationalStatusEnum new_status, bool persist);
 
    void set_connector_operative_status(int32_t evse_id, int32_t connector_id, OperationalStatusEnum new_status,
                                        bool persist);
};
} // namespace ocpp::v2