[ocpp20] Add device model implementation + GetBaseReport implementation example in quick_start_chargepoint20

Author: c-jimenez

examples/ocpp20/common/DefaultChargePointEventsHandler.cpp

@@ -24,9 +24,11 @@ SOFTWARE.
 
 #include "DefaultChargePointEventsHandler.h"
 #include "ChargePointDemoConfig.h"
+#include "NotifyReport20.h"
 
 #include <fstream>
 #include <iostream>
+#include <thread>
 
 // With MSVC compiler, the system() call returns directly the command's return value
 #ifdef _MSC_VER
@@ -36,11 +38,16 @@ SOFTWARE.
 using namespace std;
 using namespace ocpp::types;
 using namespace ocpp::types::ocpp20;
+using namespace ocpp::messages;
+using namespace ocpp::messages::ocpp20;
 
 /** @brief Constructor */
-DefaultChargePointEventsHandler::DefaultChargePointEventsHandler(ChargePointDemoConfig& config, const std::filesystem::path& working_dir)
-    : m_config(config), m_chargepoint(nullptr), m_working_dir(working_dir), m_is_connected(false)
+DefaultChargePointEventsHandler::DefaultChargePointEventsHandler(ChargePointDemoConfig&                     config,
+                                                                 ocpp::chargepoint::ocpp20::IDeviceModel20& device_model,
+                                                                 const std::filesystem::path&               working_dir)
+    : m_config(config), m_device_model(device_model), m_chargepoint(nullptr), m_working_dir(working_dir), m_is_connected(false)
 {
+    m_device_model.registerListener(*this);
 }
 
 /** @brief Destructor */
@@ -59,6 +66,24 @@ void DefaultChargePointEventsHandler::connectionStateChanged(bool isConnected)
     m_is_connected = isConnected;
 }
 
+// IDeviceModel20 interface
+
+/** @brief Called to retrieve the value of a variable */
+void DefaultChargePointEventsHandler::getVariable(ocpp::types::ocpp20::GetVariableResultType& var)
+{
+    std::string value;
+    m_config.getDeviceModelValue(var.component, var.variable, value);
+    var.attributeValue.value().assign(std::move(value));
+}
+
+/** @brief Called to set the value of a variable */
+ocpp::types::ocpp20::SetVariableStatusEnumType DefaultChargePointEventsHandler::setVariable(
+    const ocpp::types::ocpp20::SetVariableDataType& var)
+{
+    m_config.setDeviceModelValue(var.component, var.variable, var.attributeValue.str());
+    return SetVariableStatusEnumType::Accepted;
+}
+
 // OCPP operations
 
 /** @brief Called on reception of a CancelReservation message from the central */
@@ -284,13 +309,78 @@ bool DefaultChargePointEventsHandler::onGetBaseReport(const ocpp::messages::ocpp
 {
     bool ret = true;
 
-    (void)request;
     (void)error;
     (void)message;
 
     cout << "GetBaseReport" << endl;
 
-    response.status = GenericDeviceModelStatusEnumType::NotSupported;
+    if (request.reportBase == ReportBaseEnumType::SummaryInventory)
+    {
+        response.status = GenericDeviceModelStatusEnumType::NotSupported;
+    }
+    else
+    {
+        std::thread report_thread(
+            [this, type = request.reportBase, req_id = request.requestId]
+            {
+                NotifyReportReq notif_req;
+                notif_req.requestId   = req_id;
+                notif_req.generatedAt = DateTime::now();
+                notif_req.seqNo       = 0;
+                notif_req.tbc         = false;
+
+                const auto& device_model = m_device_model.getModel();
+                for (const auto& [_, comps] : device_model.components)
+                {
+                    for (const auto& component : comps)
+                    {
+                        for (const auto& [_, vars] : component.variables)
+                        {
+                            for (const auto& [_, var] : vars)
+                            {
+                                if ((type == ReportBaseEnumType::FullInventory) || !var.attributes.type.isSet() ||
+                                    (var.attributes.mutability.value() == MutabilityEnumType::ReadWrite))
+                                {
+                                    ReportDataType report_data;
+                                    report_data.component.name.assign(component.name);
+                                    if (component.instance.isSet())
+                                    {
+                                        report_data.component.instance.value().assign(component.instance.value());
+                                    }
+                                    if (component.evse.isSet())
+                                    {
+                                        report_data.component.evse.value().id = component.evse.value();
+                                    }
+                                    if (component.connector.isSet())
+                                    {
+                                        report_data.component.evse.value().connectorId.value() = component.connector.value();
+                                    }
+                                    report_data.variable.name.assign(var.name);
+                                    if (var.instance.isSet())
+                                    {
+                                        report_data.variable.instance.value().assign(var.instance.value());
+                                    }
+                                    report_data.variableAttribute.push_back(var.attributes);
+                                    report_data.variableCharacteristics = var.characteristics;
+
+                                    notif_req.reportData.push_back(std::move(report_data));
+                                }
+                            }
+                        }
+                    }
+                }
+
+                (void)device_model;
+
+                std::this_thread::sleep_for(std::chrono::seconds(1));
+
+                NotifyReportConf notif_conf;
+                std::string      error;
+                std::string      error_msg;
+                m_chargepoint->call(notif_req, notif_conf, error, error_msg);
+            });
+        report_thread.detach();
+    }
 
     return ret;
 }
@@ -500,10 +590,7 @@ bool DefaultChargePointEventsHandler::onGetVariables(const ocpp::messages::ocpp2
 
     for (const auto& var_data : request.getVariableData)
     {
-        (void)var_data;
-
-        GetVariableResultType result;
-        result.attributeStatus = GetVariableStatusEnumType::UnknownVariable;
+        GetVariableResultType result = m_device_model.getVariable(var_data);
         response.getVariableResult.push_back(result);
     }
 
@@ -783,10 +870,7 @@ bool DefaultChargePointEventsHandler::onSetVariables(const ocpp::messages::ocpp2
 
     for (const auto& var_data : request.setVariableData)
     {
-        SetVariableResultType result;
-        result.attributeStatus = SetVariableStatusEnumType::Rejected;
-        result.component       = var_data.component;
-        result.variable        = var_data.variable;
+        SetVariableResultType result = m_device_model.setVariable(var_data);
         response.setVariableResult.push_back(result);
     }
 

examples/ocpp20/common/DefaultChargePointEventsHandler.h

@@ -27,18 +27,22 @@ SOFTWARE.
 
 #include "IChargePoint20.h"
 #include "IChargePointEventsHandler20.h"
+#include "IDeviceModel20.h"
 
 #include <filesystem>
 #include <vector>
 
 class ChargePointDemoConfig;
 
 /** @brief Default charge point event handlers implementation for the examples */
-class DefaultChargePointEventsHandler : public ocpp::chargepoint::ocpp20::IChargePointEventsHandler20
+class DefaultChargePointEventsHandler : public ocpp::chargepoint::ocpp20::IChargePointEventsHandler20,
+                                        public ocpp::chargepoint::ocpp20::IDeviceModel20::IListener
 {
   public:
     /** @brief Constructor */
-    DefaultChargePointEventsHandler(ChargePointDemoConfig& config, const std::filesystem::path& working_dir);
+    DefaultChargePointEventsHandler(ChargePointDemoConfig&                     config,
+                                    ocpp::chargepoint::ocpp20::IDeviceModel20& device_model,
+                                    const std::filesystem::path&               working_dir);
 
     /** @brief Destructor */
     virtual ~DefaultChargePointEventsHandler();
@@ -49,6 +53,14 @@ class DefaultChargePointEventsHandler : public ocpp::chargepoint::ocpp20::ICharg
     /** @brief Indicate if the Charge Point is connected */
     bool isConnected() const { return m_is_connected; }
 
+    // IDeviceModel20 interface
+
+    /** @brief Called to retrieve the value of a variable */
+    void getVariable(ocpp::types::ocpp20::GetVariableResultType& var) override;
+
+    /** @brief Called to set the value of a variable */
+    ocpp::types::ocpp20::SetVariableStatusEnumType setVariable(const ocpp::types::ocpp20::SetVariableDataType& var) override;
+
     // IChargePointEventsHandler20 interface
 
     /** @copydoc void IChargePointEventsHandler20::connectionStateChanged() */
@@ -312,6 +324,8 @@ class DefaultChargePointEventsHandler : public ocpp::chargepoint::ocpp20::ICharg
   private:
     /** @brief Configuration */
     ChargePointDemoConfig& m_config;
+    /** @brief Device model */
+    ocpp::chargepoint::ocpp20::IDeviceModel20& m_device_model;
     /** @brief Associated Charge Point instance */
     ocpp::chargepoint::ocpp20::IChargePoint20* m_chargepoint;
     /** @brief Working directory */

examples/ocpp20/common/config/ChargePointDemoConfig.h

@@ -26,6 +26,7 @@ SOFTWARE.
 #define CHARGEPOINTDEMOCONFIG_H
 
 #include "ChargePointConfig.h"
+#include "IDeviceModel20.h"
 #include "IniFile.h"
 
 /** @brief Configuration of the Charge Point demo */
@@ -41,12 +42,62 @@ class ChargePointDemoConfig
     /** @brief Set the value of a stack internal configuration key */
     void setStackConfigValue(const std::string& key, const std::string& value) { m_stack_config.setConfigValue(key, value); }
 
+    /** @brief Get the value of a variable of the device model */
+    bool getDeviceModelValue(const ocpp::types::ocpp20::ComponentType& component,
+                             const ocpp::types::ocpp20::VariableType&  variable,
+                             std::string&                              value)
+    {
+        auto ini_value = m_config.get(buildComponentName(component), buildVariableName(variable));
+        value          = ini_value.toString();
+        return true;
+    }
+
+    /** @brief Set the value of a variable of the device model */
+    bool setDeviceModelValue(const ocpp::types::ocpp20::ComponentType& component,
+                             const ocpp::types::ocpp20::VariableType&  variable,
+                             const std::string&                        value)
+    {
+        m_config.set(buildComponentName(component), buildVariableName(variable), value);
+        m_config.store();
+        return true;
+    }
+
   private:
     /** @brief Configuration file */
     ocpp::helpers::IniFile m_config;
 
     /** @brief Stack internal configuration */
     ChargePointConfig m_stack_config;
+
+    /** @brief Build the device model component unique name */
+    std::string buildComponentName(const ocpp::types::ocpp20::ComponentType& component)
+    {
+        std::string name = component.name;
+        if (component.instance.isSet())
+        {
+            name += "." + component.instance.value().str();
+        }
+        if (component.evse.isSet())
+        {
+            name += "." + std::to_string(component.evse.value().id);
+            if (component.evse.value().connectorId.isSet())
+            {
+                name += "." + std::to_string(component.evse.value().connectorId.value());
+            }
+        }
+        return name;
+    }
+
+    /** @brief Build the device model variable unique name */
+    std::string buildVariableName(const ocpp::types::ocpp20::VariableType& variable)
+    {
+        std::string name = variable.name;
+        if (variable.instance.isSet())
+        {
+            name += "." + variable.instance.value().str();
+        }
+        return name;
+    }
 };
 
 #endif // CHARGEPOINTDEMOCONFIG_H