monitoring_updater.hpp

// SPDX-License-Identifier: Apache-2.0
// Copyright 2020 - 2024 Pionix GmbH and Contributors to EVerest
 
#pragma once
 
#include <unordered_map>
 
#include <everest/timer.hpp>
 
#include <ocpp/v2/enums.hpp>
#include <ocpp/v2/ocpp_enums.hpp>
#include <ocpp/v2/ocpp_types.hpp>
 
#include <ocpp/v2/device_model_storage_interface.hpp>
 
namespace ocpp::v2 {
 
class DeviceModel;
 
enum UpdateMonitorMetaType {
    TRIGGER,
    PERIODIC
};
 
struct TriggerMetadata {
    std::uint32_t is_csms_sent_triggered : 1;
 
    std::uint32_t is_event_generated : 1;
 
    std::uint32_t is_csms_sent : 1;
 
    std::uint32_t is_cleared : 1;
};
 
struct PeriodicMetadata {
    std::chrono::time_point<std::chrono::steady_clock> last_trigger_steady;
 
    std::chrono::time_point<std::chrono::system_clock> next_trigger_clock_aligned;
};
 
struct UpdaterMonitorMeta {
    UpdateMonitorMetaType type;
 
    VariableMonitoringMeta monitor_meta;
    Component component;
    Variable variable;
 
    std::int32_t monitor_id;
 
    std::string value_previous;
    std::string value_current;
 
    std::uint32_t is_writeonly : 1;
 
    TriggerMetadata meta_trigger;
    PeriodicMetadata meta_periodic;
 
    std::vector<EventData> generated_monitor_events;
 
public:
    void set_trigger_clear_state(bool is_cleared) {
        if (type != UpdateMonitorMetaType::TRIGGER) {
            throw std::runtime_error("Clear state should never be used on a non-trigger meta!");
        }
 
        if (meta_trigger.is_cleared != is_cleared) {
            meta_trigger.is_cleared = is_cleared;
 
            // On a state change reset the CSMS sent status and
            // event generation status
            meta_trigger.is_csms_sent = 0;
            meta_trigger.is_event_generated = 0;
        }
    }
};
 
typedef std::function<void(const std::vector<EventData>&)> notify_events;
typedef std::function<bool()> is_offline;
 
class MonitoringUpdater {
 
public:
    MonitoringUpdater() = delete;
 
    MonitoringUpdater(DeviceModel& device_model, notify_events notify_csms_events, is_offline is_chargepoint_offline);
    ~MonitoringUpdater();
 
public:
    void start_monitoring();
    void stop_monitoring();
 
    void process_triggered_monitors();
 
private:
    void on_variable_changed(const std::unordered_map<int64_t, VariableMonitoringMeta>& monitors,
                             const Component& component, const Variable& variable,
                             const VariableCharacteristics& characteristics, const VariableAttribute& attribute,
                             const std::string& value_old, const std::string& value_current);
 
    void on_monitor_updated(const VariableMonitoringMeta& updated_monitor, const Component& component,
                            const Variable& variable, const VariableCharacteristics& characteristics,
                            const VariableAttribute& attribute, const std::string& current_value);
 
    void evaluate_monitor(const VariableMonitoringMeta& monitor_meta, const Component& component,
                          const Variable& variable, const VariableCharacteristics& characteristics,
                          const VariableAttribute& attribute, const std::string& value_previous,
                          const std::string& value_current);
 
    // there are also any pending alert triggered monitors, those will be processed too
    void process_monitors_internal(bool allow_periodics, bool allow_trigger);
 
    void process_monitor_meta_internal(UpdaterMonitorMeta& updater_meta_data);
 
    bool should_remove_monitor_meta_internal(const UpdaterMonitorMeta& updater_meta_data);
 
    void update_periodic_monitors_internal();
 
    void get_monitoring_info(bool& out_is_offline, int& out_offline_severity, int& out_active_monitoring_level,
                             MonitoringBaseEnum& out_active_monitoring_base);
 
    bool is_monitoring_enabled();
 
private:
    DeviceModel& device_model;
    Everest::SteadyTimer monitors_timer;
 
    // Charger to CSMS message unique ID for EventData
    std::int32_t unique_id;
 
    notify_events notify_csms_events;
    is_offline is_chargepoint_offline;
 
    std::unordered_map<std::int32_t, UpdaterMonitorMeta> updater_monitors_meta;
};
 
} // namespace ocpp::v2