Add extracted tools: CitrineOS, OpenOCPP, ShapeShifter
- CitrineOS core extracted (CSMS OCPP 2.0.1) - OpenOCPP extracted (firmware OCPP 1.6J/2.0.1) - ShapeShifter library installed (pip install -e) - ShapeShifter specification extracted - EVerest extracted TODO updated with progress
This commit is contained in:
Eric F
@@ -0,0 +1,37 @@
|
||||
#
|
||||
# AUTO GENERATED - MARKED REGIONS WILL BE KEPT
|
||||
# template version 3
|
||||
#
|
||||
|
||||
# module setup:
|
||||
# - ${MODULE_NAME}: module name
|
||||
ev_setup_cpp_module()
|
||||
|
||||
# ev@bcc62523-e22b-41d7-ba2f-825b493a3c97:v1
|
||||
# insert your custom targets and additional config variables here
|
||||
|
||||
target_compile_options(${MODULE_NAME}
|
||||
PUBLIC -Wall -Wextra -pedantic -Werror=switch)
|
||||
|
||||
target_link_libraries(${MODULE_NAME}
|
||||
PRIVATE
|
||||
atomic
|
||||
everest::everest_api_types
|
||||
everest::util
|
||||
everest::everest_api_module_helpers
|
||||
)
|
||||
# ev@bcc62523-e22b-41d7-ba2f-825b493a3c97:v1
|
||||
|
||||
target_sources(${MODULE_NAME}
|
||||
PRIVATE
|
||||
"main/generic_errorImpl.cpp"
|
||||
)
|
||||
|
||||
# ev@c55432ab-152c-45a9-9d2e-7281d50c69c3:v1
|
||||
# insert other things like install cmds etc here
|
||||
target_sources(${MODULE_NAME}
|
||||
PRIVATE
|
||||
"evse_manager_consumer_API.cpp"
|
||||
"session_info.cpp"
|
||||
)
|
||||
# ev@c55432ab-152c-45a9-9d2e-7281d50c69c3:v1
|
||||
@@ -0,0 +1,18 @@
|
||||
.. _everest_modules_handwritten_evse_manager_consumer_API:
|
||||
|
||||
.. *******************************************
|
||||
.. evse_manager_consumer_API
|
||||
.. *******************************************
|
||||
|
||||
The complete API specification can be found in the
|
||||
|
||||
``docs/source/reference/EVerest_API/evse_manager_consumer_API.yaml``
|
||||
|
||||
file in the source repository, or in the `AsyncAPI HTML documentation <../../../../api/evse_manager_consumer_API/index.html>`_ automatically generated from it.
|
||||
|
||||
Session Info
|
||||
=============
|
||||
|
||||
This API module additionally provides a ``SessionInfo`` class to represent information about EVSE sessions.
|
||||
The data for ``SessionInfo`` is not simply forwarded from the internal EVerest representation. The internal
|
||||
represenation is processed and converted to the external API representation.
|
||||
@@ -0,0 +1,366 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
// Copyright 2020 - 2026 Pionix GmbH and Contributors to EVerest
|
||||
#include "evse_manager_consumer_API.hpp"
|
||||
|
||||
#include <everest_api_types/auth/wrapper.hpp>
|
||||
#include <everest_api_types/energy/API.hpp>
|
||||
#include <everest_api_types/energy/codec.hpp>
|
||||
#include <everest_api_types/energy/wrapper.hpp>
|
||||
#include <everest_api_types/evse_board_support/API.hpp>
|
||||
#include <everest_api_types/evse_board_support/codec.hpp>
|
||||
#include <everest_api_types/evse_board_support/wrapper.hpp>
|
||||
#include <everest_api_types/evse_manager/API.hpp>
|
||||
#include <everest_api_types/evse_manager/codec.hpp>
|
||||
#include <everest_api_types/evse_manager/wrapper.hpp>
|
||||
#include <everest_api_types/generic/codec.hpp>
|
||||
#include <everest_api_types/generic/string.hpp>
|
||||
#include <everest_api_types/iso15118_charger/API.hpp>
|
||||
#include <everest_api_types/iso15118_charger/codec.hpp>
|
||||
#include <everest_api_types/iso15118_charger/wrapper.hpp>
|
||||
#include <everest_api_types/isolation_monitor/API.hpp>
|
||||
#include <everest_api_types/isolation_monitor/codec.hpp>
|
||||
#include <everest_api_types/isolation_monitor/wrapper.hpp>
|
||||
#include <everest_api_types/power_supply_DC/API.hpp>
|
||||
#include <everest_api_types/power_supply_DC/codec.hpp>
|
||||
#include <everest_api_types/power_supply_DC/wrapper.hpp>
|
||||
#include <everest_api_types/powermeter/codec.hpp>
|
||||
#include <everest_api_types/powermeter/wrapper.hpp>
|
||||
#include <everest_api_types/uk_random_delay/API.hpp>
|
||||
#include <everest_api_types/uk_random_delay/codec.hpp>
|
||||
#include <everest_api_types/uk_random_delay/wrapper.hpp>
|
||||
#include <everest_api_types/utilities/AsyncApiRequestReply.hpp>
|
||||
#include <everest_api_types/utilities/codec.hpp>
|
||||
|
||||
#include <everest/logging.hpp>
|
||||
|
||||
namespace {
|
||||
template <class T> T const& to_external_api(T const& val) {
|
||||
return val;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
namespace module {
|
||||
|
||||
namespace API_types_ext = API_types::evse_manager;
|
||||
namespace API_powermeter = API_types::powermeter;
|
||||
namespace API_iso = API_types::iso15118_charger;
|
||||
namespace API_energy = API_types::energy;
|
||||
namespace API_evse_bsp = API_types::evse_board_support;
|
||||
namespace API_imd = API_types::isolation_monitor;
|
||||
namespace API_dc = API_types::power_supply_DC;
|
||||
namespace API_random_delay = API_types::uk_random_delay;
|
||||
namespace API_generic = API_types::generic;
|
||||
using ev_API::deserialize;
|
||||
|
||||
void evse_manager_consumer_API::init() {
|
||||
invoke_init(*p_main);
|
||||
|
||||
API_types_entry::CommunicationParameters comm_params{};
|
||||
comm_params.heartbeat_period_ms = config.cfg_heartbeat_interval_ms;
|
||||
comm_params.communication_check_period_s = config.cfg_communication_check_to_s;
|
||||
comm_params.request_reply_timeout_s = config.cfg_request_reply_to_s;
|
||||
helper.init(comm_params);
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::ready() {
|
||||
invoke_ready(*p_main);
|
||||
|
||||
generate_api_cmd_get_evse();
|
||||
generate_api_cmd_enable_disable();
|
||||
generate_api_cmd_pause_charging();
|
||||
generate_api_cmd_resume_charging();
|
||||
generate_api_cmd_stop_transaction();
|
||||
generate_api_cmd_force_unlock();
|
||||
generate_api_cmd_random_delay_enable();
|
||||
generate_api_cmd_random_delay_disable();
|
||||
generate_api_cmd_random_delay_cancel();
|
||||
generate_api_cmd_random_delay_set_duration_s();
|
||||
|
||||
generate_api_var_session_event();
|
||||
generate_api_var_hlc_session_failed();
|
||||
generate_api_var_session_info(); // special, not just forwarded
|
||||
generate_api_var_ev_info();
|
||||
generate_api_var_powermeter();
|
||||
generate_api_var_evse_id();
|
||||
generate_api_var_hw_capabilities();
|
||||
generate_api_var_enforced_limits();
|
||||
generate_api_var_selected_protocol();
|
||||
generate_api_var_powermeter_public_key_ocmf();
|
||||
generate_api_var_supported_energy_transfer_modes();
|
||||
|
||||
generate_api_var_ac_nr_of_phases_available();
|
||||
generate_api_var_ac_pp_ampacity();
|
||||
generate_api_var_dlink_ready();
|
||||
generate_api_var_isolation_measurement();
|
||||
generate_api_var_dc_voltage_current();
|
||||
generate_api_var_dc_mode();
|
||||
generate_api_var_dc_capabilities();
|
||||
generate_api_var_random_delay_countdown();
|
||||
|
||||
helper.generate_api_var_communication_check(&comm_check);
|
||||
comm_check.start(config.cfg_communication_check_to_s);
|
||||
helper.setup_heartbeat_generator(&comm_check, config.cfg_heartbeat_interval_ms);
|
||||
helper.publish_ready_beacon();
|
||||
}
|
||||
|
||||
auto evse_manager_consumer_API::forward_api_var(std::string const& var) {
|
||||
using namespace API_types_ext;
|
||||
using namespace API_powermeter;
|
||||
using namespace API_generic;
|
||||
using namespace API_energy;
|
||||
using namespace API_evse_bsp;
|
||||
using namespace API_iso;
|
||||
using namespace API_imd;
|
||||
using namespace API_dc;
|
||||
using namespace API_random_delay;
|
||||
const auto topic = helper.get_topics().everest_to_extern(var);
|
||||
return [this, topic](auto const& val) {
|
||||
try {
|
||||
auto&& external = to_external_api(val);
|
||||
auto&& payload = serialize(external);
|
||||
mqtt_v.publish(topic, payload);
|
||||
} catch (const std::exception& e) {
|
||||
EVLOG_warning << "Variable: '" << topic << "' failed with -> " << e.what();
|
||||
} catch (...) {
|
||||
EVLOG_warning << "Invalid data: Cannot convert internal to external or serialize it.\n" << topic;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_cmd_get_evse() {
|
||||
helper.subscribe_api_topic("get_evse", [this](std::string const& data) {
|
||||
API_generic::RequestReply msg;
|
||||
if (deserialize(data, msg)) {
|
||||
auto reply = API_types_ext::to_external_api(r_evse_manager->call_get_evse());
|
||||
mqtt_v.publish(msg.replyTo, serialize(reply));
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
});
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_cmd_enable_disable() {
|
||||
helper.subscribe_api_topic("enable_disable", [this](std::string const& data) {
|
||||
API_generic::RequestReply msg;
|
||||
if (deserialize(data, msg)) {
|
||||
API_types_ext::EnableDisableRequest payload;
|
||||
if (deserialize(msg.payload, payload)) {
|
||||
auto reply = r_evse_manager->call_enable_disable(payload.connector_id, to_internal_api(payload.source));
|
||||
mqtt_v.publish(msg.replyTo, API_generic::serialize(reply));
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
});
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_cmd_pause_charging() {
|
||||
helper.subscribe_api_topic("pause_charging", [this](std::string const& data) {
|
||||
API_generic::RequestReply msg;
|
||||
if (deserialize(data, msg)) {
|
||||
auto result = r_evse_manager->call_pause_charging();
|
||||
mqtt_v.publish(msg.replyTo, result);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
});
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_cmd_resume_charging() {
|
||||
helper.subscribe_api_topic("resume_charging", [this](std::string const& data) {
|
||||
API_generic::RequestReply msg;
|
||||
if (deserialize(data, msg)) {
|
||||
auto result = r_evse_manager->call_resume_charging();
|
||||
mqtt_v.publish(msg.replyTo, result);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
});
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_cmd_stop_transaction() {
|
||||
helper.subscribe_api_topic("stop_transaction", [this](std::string const& data) {
|
||||
auto result = false;
|
||||
API_generic::RequestReply msg;
|
||||
if (deserialize(data, msg)) {
|
||||
API_types_ext::StopTransactionRequest_External payload;
|
||||
if (deserialize(msg.payload, payload)) {
|
||||
result = r_evse_manager->call_stop_transaction(API_types_ext::to_internal_api(payload));
|
||||
mqtt_v.publish(msg.replyTo, result);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
});
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_cmd_force_unlock() {
|
||||
helper.subscribe_api_topic("force_unlock", [this](std::string const& data) {
|
||||
API_generic::RequestReply msg;
|
||||
if (deserialize(data, msg)) {
|
||||
int payload;
|
||||
if (deserialize(msg.payload, payload)) {
|
||||
auto result = r_evse_manager->call_force_unlock(payload);
|
||||
mqtt_v.publish(msg.replyTo, result);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
});
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_cmd_random_delay_enable() {
|
||||
if (not r_random_delay.empty()) {
|
||||
helper.subscribe_api_topic("random_delay_enable", [this](std::string const&) {
|
||||
r_random_delay[0]->call_enable();
|
||||
return true;
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_cmd_random_delay_disable() {
|
||||
if (not r_random_delay.empty()) {
|
||||
helper.subscribe_api_topic("random_delay_disable", [=](std::string const&) {
|
||||
r_random_delay[0]->call_disable();
|
||||
return true;
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_cmd_random_delay_cancel() {
|
||||
if (not r_random_delay.empty()) {
|
||||
helper.subscribe_api_topic("random_delay_cancel", [=](std::string const&) {
|
||||
r_random_delay[0]->call_cancel();
|
||||
return true;
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_cmd_random_delay_set_duration_s() {
|
||||
if (not r_random_delay.empty())
|
||||
helper.subscribe_api_topic("random_delay_set_duration_s", [=](std::string const& data) {
|
||||
int32_t duration;
|
||||
if (deserialize(data, duration)) {
|
||||
r_random_delay[0]->call_set_duration_s(duration);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
});
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_var_session_event() {
|
||||
r_evse_manager->subscribe_session_event(forward_api_var("session_event"));
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_var_hlc_session_failed() {
|
||||
r_evse_manager->subscribe_hlc_session_failed(forward_api_var("hlc_session_failed"));
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_var_ev_info() {
|
||||
r_evse_manager->subscribe_ev_info(forward_api_var("ev_info"));
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_var_powermeter() {
|
||||
r_evse_manager->subscribe_powermeter(forward_api_var("powermeter"));
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_var_evse_id() {
|
||||
r_evse_manager->subscribe_evse_id(forward_api_var("evse_id"));
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_var_hw_capabilities() {
|
||||
r_evse_manager->subscribe_hw_capabilities(forward_api_var("hw_capabilities"));
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_var_enforced_limits() {
|
||||
r_evse_manager->subscribe_enforced_limits(forward_api_var("enforced_limits"));
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_var_selected_protocol() {
|
||||
r_evse_manager->subscribe_selected_protocol(forward_api_var("selected_protocol"));
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_var_supported_energy_transfer_modes() {
|
||||
r_evse_manager->subscribe_supported_energy_transfer_modes(forward_api_var("supported_energy_transfer_modes"));
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_var_powermeter_public_key_ocmf() {
|
||||
r_evse_manager->subscribe_powermeter_public_key_ocmf(forward_api_var("powermeter_public_key_ocmf"));
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_var_ac_nr_of_phases_available() {
|
||||
if (not r_evse_bsp.empty()) {
|
||||
r_evse_bsp[0]->subscribe_ac_nr_of_phases_available(forward_api_var("ac_nr_of_phases_available"));
|
||||
}
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_var_ac_pp_ampacity() {
|
||||
if (not r_evse_bsp.empty()) {
|
||||
r_evse_bsp[0]->subscribe_ac_pp_ampacity(forward_api_var("ac_pp_ampacity"));
|
||||
}
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_var_dlink_ready() {
|
||||
if (not r_slac.empty()) {
|
||||
r_slac[0]->subscribe_dlink_ready(forward_api_var("dlink_ready"));
|
||||
}
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_var_isolation_measurement() {
|
||||
if (not r_imd.empty()) {
|
||||
r_imd[0]->subscribe_isolation_measurement(forward_api_var("isolation_measurement"));
|
||||
}
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_var_dc_voltage_current() {
|
||||
if (not r_ps_dc.empty()) {
|
||||
r_ps_dc[0]->subscribe_voltage_current(forward_api_var("dc_voltage_current"));
|
||||
}
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_var_dc_mode() {
|
||||
if (not r_ps_dc.empty()) {
|
||||
r_ps_dc[0]->subscribe_mode(forward_api_var("dc_mode"));
|
||||
}
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_var_dc_capabilities() {
|
||||
if (not r_ps_dc.empty()) {
|
||||
r_ps_dc[0]->subscribe_capabilities(forward_api_var("dc_capabilities"));
|
||||
}
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_var_random_delay_countdown() {
|
||||
if (not r_random_delay.empty()) {
|
||||
r_random_delay[0]->subscribe_countdown(forward_api_var("random_delay_countdown"));
|
||||
}
|
||||
}
|
||||
|
||||
void evse_manager_consumer_API::generate_api_var_session_info() {
|
||||
this->session_info.handle()->set_publish_callback(
|
||||
[this](const everest::lib::API::V1_0::types::evse_manager::SessionInfo& external) {
|
||||
static const auto topic = helper.get_topics().everest_to_extern("session_info");
|
||||
try {
|
||||
auto&& payload = serialize(external);
|
||||
mqtt_v.publish(topic, payload);
|
||||
} catch (const std::exception& e) {
|
||||
EVLOG_warning << "Variable: '" << topic << "' failed with -> " << e.what();
|
||||
} catch (...) {
|
||||
EVLOG_warning << "Invalid data: Cannot convert internal to external or serialize it.\n" << topic;
|
||||
}
|
||||
});
|
||||
|
||||
this->r_evse_manager->subscribe_session_event([this](types::evse_manager::SessionEvent const& session_event) {
|
||||
session_info.handle()->update_state(session_event);
|
||||
});
|
||||
|
||||
this->r_evse_manager->subscribe_powermeter([this](types::powermeter::Powermeter const& powermeter) {
|
||||
session_info.handle()->update_powermeter(powermeter);
|
||||
});
|
||||
|
||||
this->r_evse_manager->subscribe_selected_protocol(
|
||||
[this](std::string const& protocol) { session_info.handle()->update_selected_protocol(protocol); });
|
||||
}
|
||||
|
||||
} // namespace module
|
||||
@@ -0,0 +1,141 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
// Copyright 2020 - 2026 Pionix GmbH and Contributors to EVerest
|
||||
#ifndef EVSE_MANAGER_CONSUMER_API_HPP
|
||||
#define EVSE_MANAGER_CONSUMER_API_HPP
|
||||
|
||||
//
|
||||
// AUTO GENERATED - MARKED REGIONS WILL BE KEPT
|
||||
// template version 2
|
||||
//
|
||||
|
||||
#include "ld-ev.hpp"
|
||||
|
||||
// headers for provided interface implementations
|
||||
#include <generated/interfaces/generic_error/Implementation.hpp>
|
||||
|
||||
// headers for required interface implementations
|
||||
#include <generated/interfaces/evse_board_support/Interface.hpp>
|
||||
#include <generated/interfaces/evse_manager/Interface.hpp>
|
||||
#include <generated/interfaces/isolation_monitor/Interface.hpp>
|
||||
#include <generated/interfaces/power_supply_DC/Interface.hpp>
|
||||
#include <generated/interfaces/slac/Interface.hpp>
|
||||
#include <generated/interfaces/uk_random_delay/Interface.hpp>
|
||||
|
||||
// ev@4bf81b14-a215-475c-a1d3-0a484ae48918:v1
|
||||
// insert your custom include headers here
|
||||
#include <everest/util/async/monitor.hpp>
|
||||
#include <everest_api_module_helpers/ApiHelper.hpp>
|
||||
#include <everest_api_types/entrypoint/API.hpp>
|
||||
|
||||
#include "session_info.hpp"
|
||||
|
||||
namespace ev_API = everest::lib::API;
|
||||
namespace API_types = ev_API::V1_0::types;
|
||||
namespace API_types_entry = API_types::entrypoint;
|
||||
// ev@4bf81b14-a215-475c-a1d3-0a484ae48918:v1
|
||||
|
||||
namespace module {
|
||||
|
||||
struct Conf {
|
||||
int cfg_communication_check_to_s;
|
||||
int cfg_heartbeat_interval_ms;
|
||||
int cfg_request_reply_to_s;
|
||||
};
|
||||
|
||||
class evse_manager_consumer_API : public Everest::ModuleBase {
|
||||
public:
|
||||
evse_manager_consumer_API() = delete;
|
||||
evse_manager_consumer_API(const ModuleInfo& info, Everest::MqttProvider& mqtt_provider,
|
||||
std::unique_ptr<generic_errorImplBase> p_main,
|
||||
std::unique_ptr<evse_managerIntf> r_evse_manager,
|
||||
std::vector<std::unique_ptr<evse_board_supportIntf>> r_evse_bsp,
|
||||
std::vector<std::unique_ptr<slacIntf>> r_slac,
|
||||
std::vector<std::unique_ptr<isolation_monitorIntf>> r_imd,
|
||||
std::vector<std::unique_ptr<power_supply_DCIntf>> r_ps_dc,
|
||||
std::vector<std::unique_ptr<uk_random_delayIntf>> r_random_delay, Conf& config) :
|
||||
ModuleBase(info),
|
||||
mqtt(mqtt_provider),
|
||||
p_main(std::move(p_main)),
|
||||
r_evse_manager(std::move(r_evse_manager)),
|
||||
r_evse_bsp(std::move(r_evse_bsp)),
|
||||
r_slac(std::move(r_slac)),
|
||||
r_imd(std::move(r_imd)),
|
||||
r_ps_dc(std::move(r_ps_dc)),
|
||||
r_random_delay(std::move(r_random_delay)),
|
||||
config(config){};
|
||||
|
||||
Everest::MqttProvider& mqtt;
|
||||
const std::unique_ptr<generic_errorImplBase> p_main;
|
||||
const std::unique_ptr<evse_managerIntf> r_evse_manager;
|
||||
const std::vector<std::unique_ptr<evse_board_supportIntf>> r_evse_bsp;
|
||||
const std::vector<std::unique_ptr<slacIntf>> r_slac;
|
||||
const std::vector<std::unique_ptr<isolation_monitorIntf>> r_imd;
|
||||
const std::vector<std::unique_ptr<power_supply_DCIntf>> r_ps_dc;
|
||||
const std::vector<std::unique_ptr<uk_random_delayIntf>> r_random_delay;
|
||||
const Conf& config;
|
||||
|
||||
// ev@1fce4c5e-0ab8-41bb-90f7-14277703d2ac:v1
|
||||
// insert your public definitions here
|
||||
ev_API::Mqtt::ValidatingMqttProxy mqtt_v{mqtt};
|
||||
ev_API::ApiHelper helper{info, mqtt_v, {{"evse_manager_consumer", 1}}, get_config_service_client()};
|
||||
// ev@1fce4c5e-0ab8-41bb-90f7-14277703d2ac:v1
|
||||
|
||||
protected:
|
||||
// ev@4714b2ab-a24f-4b95-ab81-36439e1478de:v1
|
||||
// insert your protected definitions here
|
||||
// ev@4714b2ab-a24f-4b95-ab81-36439e1478de:v1
|
||||
|
||||
private:
|
||||
friend class LdEverest;
|
||||
void init();
|
||||
void ready();
|
||||
|
||||
// ev@211cfdbe-f69a-4cd6-a4ec-f8aaa3d1b6c8:v1
|
||||
// insert your private definitions here
|
||||
auto forward_api_var(std::string const& var);
|
||||
|
||||
void generate_api_cmd_get_evse();
|
||||
void generate_api_cmd_enable_disable();
|
||||
void generate_api_cmd_pause_charging();
|
||||
void generate_api_cmd_resume_charging();
|
||||
void generate_api_cmd_stop_transaction();
|
||||
void generate_api_cmd_force_unlock();
|
||||
void generate_api_cmd_random_delay_enable();
|
||||
void generate_api_cmd_random_delay_disable();
|
||||
void generate_api_cmd_random_delay_cancel();
|
||||
void generate_api_cmd_random_delay_set_duration_s();
|
||||
|
||||
void generate_api_var_session_event();
|
||||
void generate_api_var_hlc_session_failed();
|
||||
void generate_api_var_session_info();
|
||||
void generate_api_var_ev_info();
|
||||
void generate_api_var_powermeter();
|
||||
void generate_api_var_evse_id();
|
||||
void generate_api_var_hw_capabilities();
|
||||
void generate_api_var_enforced_limits();
|
||||
void generate_api_var_selected_protocol();
|
||||
void generate_api_var_powermeter_public_key_ocmf();
|
||||
void generate_api_var_supported_energy_transfer_modes();
|
||||
|
||||
void generate_api_var_ac_nr_of_phases_available();
|
||||
void generate_api_var_ac_pp_ampacity();
|
||||
void generate_api_var_dlink_ready();
|
||||
void generate_api_var_isolation_measurement();
|
||||
void generate_api_var_dc_voltage_current();
|
||||
void generate_api_var_dc_mode();
|
||||
void generate_api_var_dc_capabilities();
|
||||
void generate_api_var_random_delay_countdown();
|
||||
|
||||
ev_API::CommCheckHandler<generic_errorImplBase> comm_check{"generic/CommunicationFault",
|
||||
ev_API::bridge_connection_lost_message, p_main};
|
||||
everest::lib::util::monitor<SessionInfo> session_info;
|
||||
// ev@211cfdbe-f69a-4cd6-a4ec-f8aaa3d1b6c8:v1
|
||||
};
|
||||
|
||||
// ev@087e516b-124c-48df-94fb-109508c7cda9:v1
|
||||
// insert other definitions here
|
||||
// ev@087e516b-124c-48df-94fb-109508c7cda9:v1
|
||||
|
||||
} // namespace module
|
||||
|
||||
#endif // EVSE_MANAGER_CONSUMER_API_HPP
|
||||
@@ -0,0 +1,16 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
// Copyright 2020 - 2025 Pionix GmbH and Contributors to EVerest
|
||||
|
||||
#include "generic_errorImpl.hpp"
|
||||
|
||||
namespace module {
|
||||
namespace main {
|
||||
|
||||
void generic_errorImpl::init() {
|
||||
}
|
||||
|
||||
void generic_errorImpl::ready() {
|
||||
}
|
||||
|
||||
} // namespace main
|
||||
} // namespace module
|
||||
@@ -0,0 +1,61 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
// Copyright 2020 - 2025 Pionix GmbH and Contributors to EVerest
|
||||
#ifndef MAIN_GENERIC_ERROR_IMPL_HPP
|
||||
#define MAIN_GENERIC_ERROR_IMPL_HPP
|
||||
|
||||
//
|
||||
// AUTO GENERATED - MARKED REGIONS WILL BE KEPT
|
||||
// template version 3
|
||||
//
|
||||
|
||||
#include <generated/interfaces/generic_error/Implementation.hpp>
|
||||
|
||||
#include "../evse_manager_consumer_API.hpp"
|
||||
|
||||
// ev@75ac1216-19eb-4182-a85c-820f1fc2c091:v1
|
||||
// insert your custom include headers here
|
||||
// ev@75ac1216-19eb-4182-a85c-820f1fc2c091:v1
|
||||
|
||||
namespace module {
|
||||
namespace main {
|
||||
|
||||
struct Conf {};
|
||||
|
||||
class generic_errorImpl : public generic_errorImplBase {
|
||||
public:
|
||||
generic_errorImpl() = delete;
|
||||
generic_errorImpl(Everest::ModuleAdapter* ev, const Everest::PtrContainer<evse_manager_consumer_API>& mod,
|
||||
Conf& config) :
|
||||
generic_errorImplBase(ev, "main"), mod(mod), config(config){};
|
||||
|
||||
// ev@8ea32d28-373f-4c90-ae5e-b4fcc74e2a61:v1
|
||||
// insert your public definitions here
|
||||
// ev@8ea32d28-373f-4c90-ae5e-b4fcc74e2a61:v1
|
||||
|
||||
protected:
|
||||
// no commands defined for this interface
|
||||
|
||||
// ev@d2d1847a-7b88-41dd-ad07-92785f06f5c4:v1
|
||||
// insert your protected definitions here
|
||||
// ev@d2d1847a-7b88-41dd-ad07-92785f06f5c4:v1
|
||||
|
||||
private:
|
||||
const Everest::PtrContainer<evse_manager_consumer_API>& mod;
|
||||
const Conf& config;
|
||||
|
||||
virtual void init() override;
|
||||
virtual void ready() override;
|
||||
|
||||
// ev@3370e4dd-95f4-47a9-aaec-ea76f34a66c9:v1
|
||||
// insert your private definitions here
|
||||
// ev@3370e4dd-95f4-47a9-aaec-ea76f34a66c9:v1
|
||||
};
|
||||
|
||||
// ev@3d7da0ad-02c2-493d-9920-0bbbd56b9876:v1
|
||||
// insert other definitions here
|
||||
// ev@3d7da0ad-02c2-493d-9920-0bbbd56b9876:v1
|
||||
|
||||
} // namespace main
|
||||
} // namespace module
|
||||
|
||||
#endif // MAIN_GENERIC_ERROR_IMPL_HPP
|
||||
@@ -0,0 +1,53 @@
|
||||
description: API for using EVSE manager (consumer API)
|
||||
config:
|
||||
cfg_communication_check_to_s:
|
||||
description: "Maximum time between two communication check events. Values <= 0 disables communication checks."
|
||||
type: integer
|
||||
default: 5
|
||||
cfg_heartbeat_interval_ms:
|
||||
description: "Interval between two heartbeat messages send by the API. Values <= 0 disable heartbeat."
|
||||
type: integer
|
||||
default: 1000
|
||||
cfg_request_reply_to_s:
|
||||
description: "Maximum time between request and reply. After timeout the request is answered with a default response."
|
||||
type: integer
|
||||
default: 550
|
||||
minimum: 1
|
||||
maximum: 550
|
||||
|
||||
provides:
|
||||
main:
|
||||
interface: generic_error
|
||||
description: "Provides errors types for module communication status."
|
||||
requires:
|
||||
evse_manager:
|
||||
interface: evse_manager
|
||||
evse_bsp:
|
||||
interface: evse_board_support
|
||||
min_connections: 0
|
||||
max_connections: 1
|
||||
slac:
|
||||
interface: slac
|
||||
min_connections: 0
|
||||
max_connections: 1
|
||||
imd:
|
||||
interface: isolation_monitor
|
||||
min_connections: 0
|
||||
max_connections: 1
|
||||
ps_dc:
|
||||
interface: power_supply_DC
|
||||
min_connections: 0
|
||||
max_connections: 1
|
||||
random_delay:
|
||||
interface: uk_random_delay
|
||||
min_connections: 0
|
||||
max_connections: 1
|
||||
|
||||
enable_external_mqtt: true
|
||||
enable_global_errors: true
|
||||
metadata:
|
||||
license: https://opensource.org/licenses/Apache-2.0
|
||||
authors:
|
||||
- James Chapman
|
||||
- Jan Christoph Habig
|
||||
- Florin Mihut
|
||||
@@ -0,0 +1,231 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
// Copyright 2020 - 2025 Pionix GmbH and Contributors to EVerest
|
||||
|
||||
#include "session_info.hpp"
|
||||
#include <everest/logging.hpp>
|
||||
#include <utils/date.hpp>
|
||||
namespace module {
|
||||
|
||||
using namespace everest::lib::API::V1_0::types::evse_manager;
|
||||
|
||||
SessionInfo::SessionInfo() :
|
||||
publish_cb([](auto) {}),
|
||||
start_energy_import_wh(0),
|
||||
end_energy_import_wh(0),
|
||||
start_energy_export_wh(0),
|
||||
end_energy_export_wh(0) {
|
||||
this->session_start_time_point = date::utc_clock::now();
|
||||
this->session_end_time_point = this->session_start_time_point;
|
||||
this->transaction_start_time_point = this->session_start_time_point;
|
||||
this->transaction_end_time_point = this->session_start_time_point;
|
||||
}
|
||||
|
||||
void SessionInfo::set_publish_callback(PublishCallback cb) {
|
||||
this->publish_cb = [cb](everest::lib::API::V1_0::types::evse_manager::SessionInfo ext) {
|
||||
ext.timestamp = Everest::Date::to_rfc3339(date::utc_clock::now());
|
||||
cb(ext);
|
||||
};
|
||||
}
|
||||
|
||||
void SessionInfo::update_state(const types::evse_manager::SessionEvent& session_event) {
|
||||
using Event = types::evse_manager::SessionEventEnum;
|
||||
|
||||
try {
|
||||
switch (session_event.event) {
|
||||
case Event::Enabled:
|
||||
this->ext.state = EvseStateEnum::Unplugged;
|
||||
break;
|
||||
case Event::Disabled:
|
||||
this->ext.state = EvseStateEnum::Disabled;
|
||||
break;
|
||||
case Event::AuthRequired:
|
||||
this->ext.state = EvseStateEnum::AuthRequired;
|
||||
break;
|
||||
case Event::SessionStarted:
|
||||
this->handle_session_started(session_event);
|
||||
this->ext.state = EvseStateEnum::Preparing;
|
||||
break;
|
||||
case Event::PrepareCharging:
|
||||
this->ext.state = EvseStateEnum::Preparing;
|
||||
break;
|
||||
case Event::TransactionStarted:
|
||||
this->handle_transaction_started(session_event);
|
||||
break;
|
||||
case Event::ChargingStarted:
|
||||
this->ext.state = EvseStateEnum::Charging;
|
||||
break;
|
||||
case Event::ChargingPausedEV:
|
||||
this->ext.state = EvseStateEnum::ChargingPausedEV;
|
||||
break;
|
||||
case Event::ChargingPausedEVSE:
|
||||
this->ext.state = EvseStateEnum::ChargingPausedEVSE;
|
||||
break;
|
||||
case Event::ChargingFinished:
|
||||
this->ext.state = EvseStateEnum::Finished;
|
||||
break;
|
||||
case Event::StoppingCharging:
|
||||
this->ext.state = EvseStateEnum::FinishedEV;
|
||||
break;
|
||||
case Event::TransactionFinished: {
|
||||
this->handle_transaction_finished(session_event);
|
||||
break;
|
||||
}
|
||||
case Event::PluginTimeout:
|
||||
this->ext.state = EvseStateEnum::AuthTimeout;
|
||||
break;
|
||||
case Event::SessionFinished:
|
||||
this->handle_session_finished(session_event);
|
||||
break;
|
||||
case Event::ReservationStart:
|
||||
case Event::ReservationEnd:
|
||||
default:
|
||||
break;
|
||||
}
|
||||
publish_cb(this->ext);
|
||||
} catch (const std::exception& e) {
|
||||
EVLOG_warning << "Session event handling failed with -> " << e.what();
|
||||
}
|
||||
}
|
||||
|
||||
void SessionInfo::update_powermeter(const types::powermeter::Powermeter& powermeter) {
|
||||
try {
|
||||
this->set_latest_energy_import_wh(powermeter.energy_Wh_import.total);
|
||||
if (powermeter.energy_Wh_export.has_value()) {
|
||||
this->set_latest_energy_export_wh(powermeter.energy_Wh_export.value().total);
|
||||
}
|
||||
|
||||
if (powermeter.power_W.has_value()) {
|
||||
this->ext.latest_total_w = powermeter.power_W.value().total;
|
||||
}
|
||||
|
||||
if (this->is_session_running()) {
|
||||
publish_cb(this->ext);
|
||||
}
|
||||
} catch (const std::exception& e) {
|
||||
EVLOG_warning << "Powermeter update handling failed with -> " << e.what();
|
||||
}
|
||||
}
|
||||
|
||||
void SessionInfo::update_selected_protocol(const std::string& protocol) {
|
||||
try {
|
||||
this->ext.selected_protocol = protocol;
|
||||
if (this->is_session_running()) {
|
||||
publish_cb(this->ext);
|
||||
}
|
||||
} catch (const std::exception& e) {
|
||||
EVLOG_warning << "Selected protocol update handling failed with -> " << e.what();
|
||||
}
|
||||
}
|
||||
|
||||
void SessionInfo::handle_session_started(const types::evse_manager::SessionEvent& session_event) {
|
||||
this->session_start_time_point = Everest::Date::from_rfc3339(session_event.timestamp);
|
||||
this->session_end_time_point = this->session_start_time_point;
|
||||
this->start_energy_import_wh = this->end_energy_import_wh;
|
||||
this->start_energy_export_wh = this->end_energy_export_wh;
|
||||
|
||||
this->ext.state = EvseStateEnum::Unknown;
|
||||
this->ext.charged_energy_wh = 0;
|
||||
this->ext.discharged_energy_wh = 0;
|
||||
this->ext.session_duration_s = 0;
|
||||
this->ext.transaction_duration_s.reset();
|
||||
this->ext.latest_total_w = 0;
|
||||
this->ext.selected_protocol.reset();
|
||||
this->ext.transaction_start_time.reset();
|
||||
this->ext.transaction_end_time.reset();
|
||||
this->ext.session_end_time.reset();
|
||||
this->ext.session_start_time = Everest::Date::to_rfc3339(this->session_start_time_point);
|
||||
}
|
||||
|
||||
void SessionInfo::handle_session_finished(const types::evse_manager::SessionEvent& session_event) {
|
||||
this->ext.session_end_time = session_event.timestamp;
|
||||
this->ext.state = EvseStateEnum::Unplugged;
|
||||
}
|
||||
|
||||
void SessionInfo::handle_transaction_started(const types::evse_manager::SessionEvent& session_event) {
|
||||
this->ext.state = EvseStateEnum::Preparing;
|
||||
this->transaction_running = true;
|
||||
|
||||
if (!session_event.transaction_started.has_value()) {
|
||||
return;
|
||||
}
|
||||
|
||||
auto transaction_started = session_event.transaction_started.value();
|
||||
this->transaction_start_time_point = Everest::Date::from_rfc3339(session_event.timestamp);
|
||||
this->transaction_end_time_point = this->transaction_start_time_point;
|
||||
this->start_energy_import_wh = transaction_started.meter_value.energy_Wh_import.total;
|
||||
|
||||
this->end_energy_import_wh = this->start_energy_import_wh;
|
||||
this->transaction_end_time_point = this->transaction_start_time_point;
|
||||
|
||||
if (transaction_started.meter_value.energy_Wh_export.has_value()) {
|
||||
auto energy_Wh_export = transaction_started.meter_value.energy_Wh_export.value().total;
|
||||
this->start_energy_export_wh = energy_Wh_export;
|
||||
this->end_energy_export_wh = energy_Wh_export;
|
||||
this->start_energy_export_wh_was_set = true;
|
||||
} else {
|
||||
this->start_energy_export_wh_was_set = false;
|
||||
}
|
||||
|
||||
this->ext.transaction_start_time = Everest::Date::to_rfc3339(this->transaction_start_time_point);
|
||||
}
|
||||
|
||||
void SessionInfo::handle_transaction_finished(const types::evse_manager::SessionEvent& session_event) {
|
||||
this->ext.state = EvseStateEnum::Finished;
|
||||
|
||||
if (!session_event.transaction_finished.has_value()) {
|
||||
return;
|
||||
}
|
||||
|
||||
auto transaction_finished = session_event.transaction_finished.value();
|
||||
|
||||
if (transaction_finished.reason == types::evse_manager::StopTransactionReason::Local) {
|
||||
this->ext.state = EvseStateEnum::FinishedEVSE;
|
||||
}
|
||||
|
||||
auto energy_Wh_import = transaction_finished.meter_value.energy_Wh_import.total;
|
||||
this->end_energy_import_wh = energy_Wh_import;
|
||||
this->transaction_end_time_point = Everest::Date::from_rfc3339(session_event.timestamp);
|
||||
this->transaction_running = false;
|
||||
|
||||
if (transaction_finished.meter_value.energy_Wh_export.has_value()) {
|
||||
auto energy_Wh_export = transaction_finished.meter_value.energy_Wh_export.value().total;
|
||||
this->end_energy_export_wh = energy_Wh_export;
|
||||
this->end_energy_export_wh_was_set = true;
|
||||
} else {
|
||||
this->end_energy_export_wh_was_set = false;
|
||||
}
|
||||
|
||||
this->ext.transaction_end_time = Everest::Date::to_rfc3339(this->transaction_end_time_point);
|
||||
}
|
||||
|
||||
void SessionInfo::set_latest_energy_import_wh(int32_t latest_energy_wh_import) {
|
||||
this->ext.charged_energy_wh = this->end_energy_import_wh - this->start_energy_import_wh;
|
||||
if (this->start_energy_export_wh_was_set && this->end_energy_export_wh_was_set) {
|
||||
this->ext.discharged_energy_wh = this->end_energy_export_wh - this->start_energy_export_wh;
|
||||
}
|
||||
|
||||
this->ext.session_duration_s =
|
||||
std::chrono::duration_cast<std::chrono::seconds>(this->session_end_time_point - this->session_start_time_point)
|
||||
.count();
|
||||
this->session_end_time_point = date::utc_clock::now();
|
||||
|
||||
if (transaction_running) {
|
||||
this->ext.transaction_duration_s = std::chrono::duration_cast<std::chrono::seconds>(
|
||||
this->transaction_end_time_point - this->transaction_start_time_point)
|
||||
.count();
|
||||
this->transaction_end_time_point = this->session_end_time_point;
|
||||
this->end_energy_import_wh = latest_energy_wh_import;
|
||||
}
|
||||
}
|
||||
|
||||
void SessionInfo::set_latest_energy_export_wh(int32_t latest_export_energy_wh) {
|
||||
this->end_energy_export_wh = latest_export_energy_wh;
|
||||
this->end_energy_export_wh_was_set = true;
|
||||
}
|
||||
|
||||
bool SessionInfo::is_session_running() {
|
||||
return this->ext.state != EvseStateEnum::Unplugged && this->ext.state != EvseStateEnum::Disabled and
|
||||
this->ext.state != EvseStateEnum::Unknown;
|
||||
}
|
||||
|
||||
} // namespace module
|
||||
@@ -0,0 +1,57 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
// Copyright 2020 - 2025 Pionix GmbH and Contributors to EVerest
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <chrono>
|
||||
#include <date/date.h>
|
||||
#include <date/tz.h>
|
||||
#include <mutex>
|
||||
#include <string>
|
||||
|
||||
#include <everest_api_types/evse_manager/API.hpp>
|
||||
#include <generated/types/evse_manager.hpp>
|
||||
namespace module {
|
||||
|
||||
/// \brief Session and transaction information for EVSE
|
||||
class SessionInfo {
|
||||
public:
|
||||
using PublishCallback = std::function<void(everest::lib::API::V1_0::types::evse_manager::SessionInfo)>;
|
||||
SessionInfo();
|
||||
|
||||
void set_publish_callback(PublishCallback cb);
|
||||
|
||||
void update_state(const types::evse_manager::SessionEvent& session_event);
|
||||
void update_powermeter(const types::powermeter::Powermeter& powermeter);
|
||||
void update_selected_protocol(const std::string& protocol);
|
||||
|
||||
private:
|
||||
PublishCallback publish_cb;
|
||||
/// \brief External API representation
|
||||
everest::lib::API::V1_0::types::evse_manager::SessionInfo ext;
|
||||
|
||||
bool start_energy_export_wh_was_set{
|
||||
false}; ///< Indicate if start export energy value (optional) has been received or not
|
||||
bool end_energy_export_wh_was_set{
|
||||
false}; ///< Indicate if end export energy value (optional) has been received or not
|
||||
bool transaction_running{false};
|
||||
|
||||
int32_t start_energy_import_wh; ///< Energy reading (import) at the beginning of this charging session in Wh
|
||||
int32_t end_energy_import_wh; ///< Energy reading (import) at the end of this charging session in Wh
|
||||
int32_t start_energy_export_wh; ///< Energy reading (export) at the beginning of this charging session in Wh
|
||||
int32_t end_energy_export_wh; ///< Energy reading (export) at the end of this charging session in Wh
|
||||
std::chrono::time_point<date::utc_clock> session_start_time_point; ///< Start of the charging session
|
||||
std::chrono::time_point<date::utc_clock> session_end_time_point; ///< End of the charging session
|
||||
std::chrono::time_point<date::utc_clock> transaction_start_time_point; ///< Start of the transaction
|
||||
std::chrono::time_point<date::utc_clock> transaction_end_time_point; ///< End of the transaction
|
||||
|
||||
void handle_session_started(const types::evse_manager::SessionEvent& session_event);
|
||||
void handle_session_finished(const types::evse_manager::SessionEvent& session_event);
|
||||
void handle_transaction_started(const types::evse_manager::SessionEvent& session_event);
|
||||
void handle_transaction_finished(const types::evse_manager::SessionEvent& session_event);
|
||||
void set_latest_energy_import_wh(int32_t latest_energy_wh_import);
|
||||
void set_latest_energy_export_wh(int32_t latest_export_energy_wh);
|
||||
bool is_session_running();
|
||||
};
|
||||
|
||||
} // namespace module
|
||||
Reference in New Issue
Block a user