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,584 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
// Copyright Pionix GmbH and Contributors to EVerest
|
||||
|
||||
#include "powermeterImpl.hpp"
|
||||
#include <fmt/core.h>
|
||||
#include <functional>
|
||||
#include <optional>
|
||||
#include <thread>
|
||||
#include <utils/date.hpp>
|
||||
#include <utils/yaml_loader.hpp>
|
||||
|
||||
const std::string MODELS_SUB_DIR = "models";
|
||||
|
||||
namespace fs = std::filesystem;
|
||||
|
||||
namespace module {
|
||||
namespace main {
|
||||
|
||||
void powermeterImpl::init() {
|
||||
|
||||
const std::size_t found = this->config.model.find(".."); // check for invalid path
|
||||
if (found != std::string::npos) {
|
||||
EVLOG_error << fmt::format("Error! Substring \"..\" not allowed in given model name '{}'!", this->config.model);
|
||||
throw std::runtime_error("Incorrect model name in GenericPowermeter config");
|
||||
}
|
||||
|
||||
const auto model = this->mod->info.paths.share / MODELS_SUB_DIR / fmt::format("{}.yaml", this->config.model);
|
||||
|
||||
try {
|
||||
const json powermeter_registers = Everest::load_yaml(model);
|
||||
this->init_register_assignments(std::move(powermeter_registers));
|
||||
this->init_default_values();
|
||||
} catch (const std::exception& e) {
|
||||
EVLOG_error << "opening file \"" << this->config.model << ".yaml\" from path " << model
|
||||
<< " failed: " << e.what();
|
||||
throw std::runtime_error(fmt::format("Module \"GenericPowermeter\" could not be initialized: {}", e.what()));
|
||||
}
|
||||
}
|
||||
|
||||
void powermeterImpl::ready() {
|
||||
std::thread([this] {
|
||||
while (true) {
|
||||
this->read_powermeter_values();
|
||||
// Note: reading the power meter values may take several seconds already, so the complete loop
|
||||
// time of this function will be well beyond the sleep time given below.
|
||||
sleep(1);
|
||||
}
|
||||
}).detach();
|
||||
}
|
||||
|
||||
types::powermeter::TransactionStopResponse powermeterImpl::handle_stop_transaction(std::string& transaction_id) {
|
||||
return {types::powermeter::TransactionRequestStatus::NOT_SUPPORTED,
|
||||
{},
|
||||
{},
|
||||
"Generic powermeter does not support the stop_transaction command"};
|
||||
};
|
||||
|
||||
types::powermeter::TransactionStartResponse
|
||||
powermeterImpl::handle_start_transaction(types::powermeter::TransactionReq& value) {
|
||||
return {types::powermeter::TransactionRequestStatus::NOT_SUPPORTED,
|
||||
"Generic powermeter does not support the start_transaction command"};
|
||||
}
|
||||
|
||||
void powermeterImpl::init_default_values() {
|
||||
this->pm_last_values.timestamp = Everest::Date::to_rfc3339(date::utc_clock::now());
|
||||
this->pm_last_values.meter_id = std::string(this->mod->info.id);
|
||||
|
||||
for (const auto& register_data : this->pm_configuration) {
|
||||
if (register_data.type == ENERGY_WH_IMPORT_TOTAL) {
|
||||
this->pm_last_values.energy_Wh_import.total = 0.0f;
|
||||
} else if (register_data.type == ENERGY_WH_IMPORT_L1) {
|
||||
this->pm_last_values.energy_Wh_import.L1 = 0.0f;
|
||||
} else if (register_data.type == ENERGY_WH_IMPORT_L2) {
|
||||
this->pm_last_values.energy_Wh_import.L2 = 0.0f;
|
||||
} else if (register_data.type == ENERGY_WH_IMPORT_L3) {
|
||||
this->pm_last_values.energy_Wh_import.L3 = 0.0f;
|
||||
} else if (register_data.type == ENERGY_WH_EXPORT_TOTAL) {
|
||||
types::units::Energy energy_out;
|
||||
if (this->pm_last_values.energy_Wh_export.has_value()) {
|
||||
energy_out = this->pm_last_values.energy_Wh_export.value();
|
||||
}
|
||||
energy_out.total = 0.0f;
|
||||
this->pm_last_values.energy_Wh_export = energy_out;
|
||||
} else if (register_data.type == ENERGY_WH_EXPORT_L1) {
|
||||
types::units::Energy energy_out;
|
||||
if (this->pm_last_values.energy_Wh_export.has_value()) {
|
||||
energy_out = this->pm_last_values.energy_Wh_export.value();
|
||||
}
|
||||
energy_out.L1 = 0.0f;
|
||||
this->pm_last_values.energy_Wh_export = energy_out;
|
||||
} else if (register_data.type == ENERGY_WH_EXPORT_L2) {
|
||||
types::units::Energy energy_out;
|
||||
if (this->pm_last_values.energy_Wh_export.has_value()) {
|
||||
energy_out = this->pm_last_values.energy_Wh_export.value();
|
||||
}
|
||||
energy_out.L2 = 0.0f;
|
||||
this->pm_last_values.energy_Wh_export = energy_out;
|
||||
} else if (register_data.type == ENERGY_WH_EXPORT_L3) {
|
||||
types::units::Energy energy_out;
|
||||
if (this->pm_last_values.energy_Wh_export.has_value()) {
|
||||
energy_out = this->pm_last_values.energy_Wh_export.value();
|
||||
}
|
||||
energy_out.L3 = 0.0f;
|
||||
this->pm_last_values.energy_Wh_export = energy_out;
|
||||
} else if (register_data.type == POWER_W_TOTAL) {
|
||||
types::units::Power pwr;
|
||||
if (this->pm_last_values.power_W.has_value()) {
|
||||
pwr = this->pm_last_values.power_W.value();
|
||||
}
|
||||
pwr.total = 0.0f;
|
||||
this->pm_last_values.power_W = pwr;
|
||||
} else if (register_data.type == POWER_W_L1) {
|
||||
types::units::Power pwr;
|
||||
if (this->pm_last_values.power_W.has_value()) {
|
||||
pwr = this->pm_last_values.power_W.value();
|
||||
}
|
||||
pwr.L1 = 0.0f;
|
||||
this->pm_last_values.power_W = pwr;
|
||||
} else if (register_data.type == POWER_W_L2) {
|
||||
types::units::Power pwr;
|
||||
if (this->pm_last_values.power_W.has_value()) {
|
||||
pwr = this->pm_last_values.power_W.value();
|
||||
}
|
||||
pwr.L2 = 0.0f;
|
||||
this->pm_last_values.power_W = pwr;
|
||||
} else if (register_data.type == POWER_W_L3) {
|
||||
types::units::Power pwr;
|
||||
if (this->pm_last_values.power_W.has_value()) {
|
||||
pwr = this->pm_last_values.power_W.value();
|
||||
}
|
||||
pwr.L3 = 0.0f;
|
||||
this->pm_last_values.power_W = pwr;
|
||||
} else if (register_data.type == VOLTAGE_V_DC) {
|
||||
types::units::Voltage volt;
|
||||
if (this->pm_last_values.voltage_V.has_value()) {
|
||||
volt = this->pm_last_values.voltage_V.value();
|
||||
}
|
||||
volt.DC = 0.0f;
|
||||
this->pm_last_values.voltage_V = volt;
|
||||
} else if (register_data.type == VOLTAGE_V_L1) {
|
||||
types::units::Voltage volt;
|
||||
if (this->pm_last_values.voltage_V.has_value()) {
|
||||
volt = this->pm_last_values.voltage_V.value();
|
||||
}
|
||||
volt.L1 = 0.0f;
|
||||
this->pm_last_values.voltage_V = volt;
|
||||
} else if (register_data.type == VOLTAGE_V_L2) {
|
||||
types::units::Voltage volt;
|
||||
if (this->pm_last_values.voltage_V.has_value()) {
|
||||
volt = this->pm_last_values.voltage_V.value();
|
||||
}
|
||||
volt.L2 = 0.0f;
|
||||
this->pm_last_values.voltage_V = volt;
|
||||
} else if (register_data.type == VOLTAGE_V_L3) {
|
||||
types::units::Voltage volt;
|
||||
if (this->pm_last_values.voltage_V.has_value()) {
|
||||
volt = this->pm_last_values.voltage_V.value();
|
||||
}
|
||||
volt.L3 = 0.0f;
|
||||
this->pm_last_values.voltage_V = volt;
|
||||
} else if (register_data.type == REACTIVE_POWER_VAR_TOTAL) {
|
||||
types::units::ReactivePower var;
|
||||
if (this->pm_last_values.VAR.has_value()) {
|
||||
var = this->pm_last_values.VAR.value();
|
||||
}
|
||||
var.total = 0.0f;
|
||||
this->pm_last_values.VAR = var;
|
||||
} else if (register_data.type == REACTIVE_POWER_VAR_L1) {
|
||||
types::units::ReactivePower var;
|
||||
if (this->pm_last_values.VAR.has_value()) {
|
||||
var = this->pm_last_values.VAR.value();
|
||||
}
|
||||
var.L1 = 0.0f;
|
||||
this->pm_last_values.VAR = var;
|
||||
} else if (register_data.type == REACTIVE_POWER_VAR_L2) {
|
||||
types::units::ReactivePower var;
|
||||
if (this->pm_last_values.VAR.has_value()) {
|
||||
var = this->pm_last_values.VAR.value();
|
||||
}
|
||||
var.L2 = 0.0f;
|
||||
this->pm_last_values.VAR = var;
|
||||
} else if (register_data.type == REACTIVE_POWER_VAR_L3) {
|
||||
types::units::ReactivePower var;
|
||||
if (this->pm_last_values.VAR.has_value()) {
|
||||
var = this->pm_last_values.VAR.value();
|
||||
}
|
||||
var.L3 = 0.0f;
|
||||
this->pm_last_values.VAR = var;
|
||||
} else if (register_data.type == CURRENT_A_DC) {
|
||||
types::units::Current amp;
|
||||
if (this->pm_last_values.current_A.has_value()) {
|
||||
amp = this->pm_last_values.current_A.value();
|
||||
}
|
||||
amp.DC = 0.0f;
|
||||
this->pm_last_values.current_A = amp;
|
||||
} else if (register_data.type == CURRENT_A_L1) {
|
||||
types::units::Current amp;
|
||||
if (this->pm_last_values.current_A.has_value()) {
|
||||
amp = this->pm_last_values.current_A.value();
|
||||
}
|
||||
amp.L1 = 0.0f;
|
||||
this->pm_last_values.current_A = amp;
|
||||
} else if (register_data.type == CURRENT_A_L2) {
|
||||
types::units::Current amp;
|
||||
if (this->pm_last_values.current_A.has_value()) {
|
||||
amp = this->pm_last_values.current_A.value();
|
||||
}
|
||||
amp.L2 = 0.0f;
|
||||
this->pm_last_values.current_A = amp;
|
||||
} else if (register_data.type == CURRENT_A_L3) {
|
||||
types::units::Current amp;
|
||||
if (this->pm_last_values.current_A.has_value()) {
|
||||
amp = this->pm_last_values.current_A.value();
|
||||
}
|
||||
amp.L3 = 0.0f;
|
||||
this->pm_last_values.current_A = amp;
|
||||
} else if (register_data.type == FREQUENCY_HZ_L1) {
|
||||
types::units::Frequency freq;
|
||||
if (this->pm_last_values.frequency_Hz.has_value()) {
|
||||
freq = this->pm_last_values.frequency_Hz.value();
|
||||
}
|
||||
freq.L1 = 0.0f;
|
||||
this->pm_last_values.frequency_Hz = freq;
|
||||
} else if (register_data.type == FREQUENCY_HZ_L2) {
|
||||
types::units::Frequency freq;
|
||||
if (this->pm_last_values.frequency_Hz.has_value()) {
|
||||
freq = this->pm_last_values.frequency_Hz.value();
|
||||
}
|
||||
freq.L2 = 0.0f;
|
||||
this->pm_last_values.frequency_Hz = freq;
|
||||
} else if (register_data.type == FREQUENCY_HZ_L3) {
|
||||
types::units::Frequency freq;
|
||||
if (this->pm_last_values.frequency_Hz.has_value()) {
|
||||
freq = this->pm_last_values.frequency_Hz.value();
|
||||
}
|
||||
freq.L3 = 0.0f;
|
||||
this->pm_last_values.frequency_Hz = freq;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void powermeterImpl::init_register_assignments(const json& loaded_registers) {
|
||||
bool failed{false};
|
||||
failed |= not this->assign_register_data(loaded_registers, ENERGY_WH_IMPORT_TOTAL, "energy_Wh_import");
|
||||
failed |= not this->assign_register_data(loaded_registers, ENERGY_WH_EXPORT_TOTAL, "energy_Wh_export");
|
||||
failed |= not this->assign_register_data(loaded_registers, POWER_W_TOTAL, "power_W");
|
||||
failed |= not this->assign_register_data(loaded_registers, VOLTAGE_V_DC, "voltage_V");
|
||||
failed |= not this->assign_register_data(loaded_registers, REACTIVE_POWER_VAR_TOTAL, "reactive_power_VAR");
|
||||
failed |= not this->assign_register_data(loaded_registers, CURRENT_A_DC, "current_A");
|
||||
failed |= not this->assign_register_data(loaded_registers, FREQUENCY_HZ_L1, "frequency_Hz");
|
||||
|
||||
if (failed) {
|
||||
EVLOG_error << "Could not load powermeter model configuration!";
|
||||
throw std::runtime_error("Could not load GenericPowermeter model configuration");
|
||||
}
|
||||
}
|
||||
|
||||
bool powermeterImpl::assign_register_data(const json& registers, const PowermeterRegisters register_type,
|
||||
const std::string& register_selector) {
|
||||
try {
|
||||
if (registers.contains(register_selector)) {
|
||||
if (registers.at(register_selector).at("num_registers") > 0) {
|
||||
RegisterData data = {};
|
||||
data.type = register_type;
|
||||
data.start_register = registers.at(register_selector).at("start_register");
|
||||
data.start_register_function = this->select_modbus_function(
|
||||
(const uint8_t)registers.at(register_selector).at("function_code_start_reg"));
|
||||
data.num_registers = registers.at(register_selector).at("num_registers");
|
||||
data.exponent_register = registers.at(register_selector).at("exponent_register");
|
||||
data.exponent_register_function = this->select_modbus_function(
|
||||
(const uint8_t)registers.at(register_selector).at("function_code_exp_reg"));
|
||||
data.multiplier = registers.at(register_selector).at("multiplier");
|
||||
this->pm_configuration.push_back(data);
|
||||
}
|
||||
if (registers.at(register_selector).contains("L1")) {
|
||||
if (registers.at(register_selector).at("L1").at("num_registers") > 0) {
|
||||
assign_register_sublevel_data(registers, register_type, register_selector, "L1", 1);
|
||||
}
|
||||
}
|
||||
if (registers.at(register_selector).contains("L2")) {
|
||||
if (registers.at(register_selector).at("L2").at("num_registers") > 0) {
|
||||
assign_register_sublevel_data(registers, register_type, register_selector, "L2", 2);
|
||||
}
|
||||
}
|
||||
if (registers.at(register_selector).contains("L3")) {
|
||||
if (registers.at(register_selector).at("L3").at("num_registers") > 0) {
|
||||
assign_register_sublevel_data(registers, register_type, register_selector, "L3", 3);
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (const std::exception& e) {
|
||||
EVLOG_error << "Assigning configuration data for register \"" << register_selector << "\" failed: " << e.what();
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void powermeterImpl::assign_register_sublevel_data(const json& registers, const PowermeterRegisters& register_type,
|
||||
const std::string& register_selector,
|
||||
const std::string& sublevel_selector, const uint8_t offset) {
|
||||
|
||||
RegisterData sublevel_data = {};
|
||||
sublevel_data.type = static_cast<PowermeterRegisters>((register_type + offset) % NUM_PM_REGISTERS);
|
||||
sublevel_data.start_register = registers.at(register_selector).at(sublevel_selector).at("start_register");
|
||||
sublevel_data.start_register_function = this->select_modbus_function(
|
||||
(const uint8_t)registers.at(register_selector).at(sublevel_selector).at("function_code_start_reg"));
|
||||
sublevel_data.num_registers = registers.at(register_selector).at(sublevel_selector).at("num_registers");
|
||||
sublevel_data.exponent_register = registers.at(register_selector).at(sublevel_selector).at("exponent_register");
|
||||
sublevel_data.exponent_register_function = this->select_modbus_function(
|
||||
(const uint8_t)registers.at(register_selector).at(sublevel_selector).at("function_code_exp_reg"));
|
||||
sublevel_data.multiplier = registers.at(register_selector).at(sublevel_selector).at("multiplier");
|
||||
this->pm_configuration.push_back(sublevel_data);
|
||||
}
|
||||
|
||||
powermeterImpl::ModbusFunctionType powermeterImpl::select_modbus_function(const uint8_t function_code) {
|
||||
switch (function_code) {
|
||||
case 0x03:
|
||||
return READ_HOLDING_REGISTER;
|
||||
break;
|
||||
|
||||
case 0x04:
|
||||
return READ_INPUT_REGISTER;
|
||||
break;
|
||||
|
||||
default:
|
||||
throw std::runtime_error(fmt::format("Incorrect Modbus RTU function code {}!", function_code));
|
||||
break;
|
||||
}
|
||||
return REGISTER_TYPE_UNDEFINED;
|
||||
}
|
||||
|
||||
void powermeterImpl::read_powermeter_values() {
|
||||
static bool pm_values_are_complete{false};
|
||||
bool all_pm_registers_success{true};
|
||||
for (const auto& register_data : this->pm_configuration) {
|
||||
all_pm_registers_success &= this->read_register(register_data);
|
||||
}
|
||||
if (all_pm_registers_success) {
|
||||
pm_values_are_complete = true;
|
||||
}
|
||||
|
||||
if (not pm_values_are_complete) {
|
||||
EVLOG_warning << "No complete set of power meter values has been acquired yet. Not publishing.";
|
||||
return;
|
||||
}
|
||||
|
||||
this->pm_last_values.timestamp = Everest::Date::to_rfc3339(date::utc_clock::now());
|
||||
this->publish_powermeter(this->pm_last_values);
|
||||
}
|
||||
|
||||
bool powermeterImpl::read_register(const RegisterData& register_config) {
|
||||
|
||||
types::serial_comm_hub_requests::Result register_response{};
|
||||
std::optional<types::serial_comm_hub_requests::Result> exponent_response;
|
||||
|
||||
if (register_config.start_register_function == READ_HOLDING_REGISTER) {
|
||||
register_response = mod->r_serial_comm_hub->call_modbus_read_holding_registers(
|
||||
this->config.powermeter_device_id, register_config.start_register, register_config.num_registers);
|
||||
} else if (register_config.start_register_function == READ_INPUT_REGISTER) {
|
||||
register_response = mod->r_serial_comm_hub->call_modbus_read_input_registers(
|
||||
this->config.powermeter_device_id, register_config.start_register - this->config.modbus_base_address,
|
||||
register_config.num_registers);
|
||||
}
|
||||
|
||||
if (register_config.exponent_register != 0) {
|
||||
if (register_config.exponent_register_function == READ_HOLDING_REGISTER) {
|
||||
exponent_response = mod->r_serial_comm_hub->call_modbus_read_holding_registers(
|
||||
this->config.powermeter_device_id, register_config.exponent_register, register_config.num_registers);
|
||||
} else if (register_config.exponent_register_function == READ_INPUT_REGISTER) {
|
||||
exponent_response = mod->r_serial_comm_hub->call_modbus_read_input_registers(
|
||||
this->config.powermeter_device_id, register_config.exponent_register - this->config.modbus_base_address,
|
||||
register_config.num_registers);
|
||||
}
|
||||
return this->process_response(register_config, std::move(register_response), std::move(exponent_response));
|
||||
} else {
|
||||
// no exponent
|
||||
return this->process_response(register_config, std::move(register_response), std::nullopt);
|
||||
}
|
||||
}
|
||||
|
||||
bool powermeterImpl::process_response(
|
||||
const RegisterData& register_data, const types::serial_comm_hub_requests::Result& register_message,
|
||||
std::optional<std::reference_wrapper<const types::serial_comm_hub_requests::Result>> exponent_message) {
|
||||
|
||||
if ((register_message.status_code != types::serial_comm_hub_requests::StatusCodeEnum::Success) ||
|
||||
(exponent_message &&
|
||||
exponent_message->get().status_code != types::serial_comm_hub_requests::StatusCodeEnum::Success)) {
|
||||
// error: message sending failed
|
||||
output_error_with_content(register_message);
|
||||
if (exponent_message) {
|
||||
output_error_with_content(exponent_message.value());
|
||||
}
|
||||
|
||||
// let's warn the user about the meter's unavailability once only
|
||||
// (since we keep trying communicating an 'error' is not justified)
|
||||
if (!meter_is_unavailable) {
|
||||
EVLOG_warning << "Lost communication with power meter.";
|
||||
meter_is_unavailable = true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
// SerialCommHub implementation should be preventing this in case of StatusCodeEnum::Success
|
||||
if (not register_message.value.has_value()) {
|
||||
EVLOG_warning << "Power meter reading returned without a value, skipping";
|
||||
return false;
|
||||
}
|
||||
if (exponent_message and not exponent_message->get().value.has_value()) {
|
||||
EVLOG_warning << "Power meter reading returned without an exponent value, skipping";
|
||||
return false;
|
||||
}
|
||||
if (register_message.value.value().size() == 0) {
|
||||
EVLOG_warning << "Power meter reading returned an empty value, skipping";
|
||||
return false;
|
||||
}
|
||||
if (exponent_message and exponent_message->get().value.value().size() == 0) {
|
||||
EVLOG_warning << "Power meter reading returned an empty exponent value, skipping";
|
||||
return false;
|
||||
}
|
||||
|
||||
// in case the meter was unavailable before and now the query succeeded,
|
||||
// we can tell the user about this good news and reset our flag
|
||||
if (meter_is_unavailable) {
|
||||
EVLOG_info << "Communication with power meter restored.";
|
||||
meter_is_unavailable = false;
|
||||
}
|
||||
|
||||
int16_t exponent = 0;
|
||||
if (exponent_message) {
|
||||
exponent = exponent_message->get().value.value().at(0);
|
||||
}
|
||||
|
||||
if (register_data.type == ENERGY_WH_IMPORT_TOTAL) {
|
||||
types::units::Energy energy_in = this->pm_last_values.energy_Wh_import;
|
||||
energy_in.total = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.energy_Wh_import = energy_in;
|
||||
} else if (register_data.type == ENERGY_WH_IMPORT_L1) {
|
||||
types::units::Energy energy_in = this->pm_last_values.energy_Wh_import;
|
||||
energy_in.L1 = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.energy_Wh_import = energy_in;
|
||||
} else if (register_data.type == ENERGY_WH_IMPORT_L2) {
|
||||
types::units::Energy energy_in = this->pm_last_values.energy_Wh_import;
|
||||
energy_in.L2 = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.energy_Wh_import = energy_in;
|
||||
} else if (register_data.type == ENERGY_WH_IMPORT_L3) {
|
||||
types::units::Energy energy_in = this->pm_last_values.energy_Wh_import;
|
||||
energy_in.L3 = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.energy_Wh_import = energy_in;
|
||||
} else if (register_data.type == ENERGY_WH_EXPORT_TOTAL) {
|
||||
types::units::Energy energy_out = this->pm_last_values.energy_Wh_export.value();
|
||||
energy_out.total = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.energy_Wh_export = energy_out;
|
||||
} else if (register_data.type == ENERGY_WH_EXPORT_L1) {
|
||||
types::units::Energy energy_out = this->pm_last_values.energy_Wh_export.value();
|
||||
energy_out.L1 = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.energy_Wh_export = energy_out;
|
||||
} else if (register_data.type == ENERGY_WH_EXPORT_L2) {
|
||||
types::units::Energy energy_out = this->pm_last_values.energy_Wh_export.value();
|
||||
energy_out.L2 = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.energy_Wh_export = energy_out;
|
||||
} else if (register_data.type == ENERGY_WH_EXPORT_L3) {
|
||||
types::units::Energy energy_out = this->pm_last_values.energy_Wh_export.value();
|
||||
energy_out.L3 = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.energy_Wh_export = energy_out;
|
||||
} else if (register_data.type == POWER_W_TOTAL) {
|
||||
types::units::Power power = this->pm_last_values.power_W.value();
|
||||
power.total = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.power_W = power;
|
||||
} else if (register_data.type == POWER_W_L1) {
|
||||
types::units::Power power = this->pm_last_values.power_W.value();
|
||||
power.L1 = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.power_W = power;
|
||||
} else if (register_data.type == POWER_W_L2) {
|
||||
types::units::Power power = this->pm_last_values.power_W.value();
|
||||
power.L2 = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.power_W = power;
|
||||
} else if (register_data.type == POWER_W_L3) {
|
||||
types::units::Power power = this->pm_last_values.power_W.value();
|
||||
power.L3 = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.power_W = power;
|
||||
} else if (register_data.type == VOLTAGE_V_DC) {
|
||||
types::units::Voltage volt = this->pm_last_values.voltage_V.value();
|
||||
volt.DC = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.voltage_V = volt;
|
||||
} else if (register_data.type == VOLTAGE_V_L1) {
|
||||
types::units::Voltage volt = this->pm_last_values.voltage_V.value();
|
||||
volt.L1 = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.voltage_V = volt;
|
||||
} else if (register_data.type == VOLTAGE_V_L2) {
|
||||
types::units::Voltage volt = this->pm_last_values.voltage_V.value();
|
||||
volt.L2 = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.voltage_V = volt;
|
||||
} else if (register_data.type == VOLTAGE_V_L3) {
|
||||
types::units::Voltage volt = this->pm_last_values.voltage_V.value();
|
||||
volt.L3 = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.voltage_V = volt;
|
||||
} else if (register_data.type == REACTIVE_POWER_VAR_TOTAL) {
|
||||
types::units::ReactivePower var = this->pm_last_values.VAR.value();
|
||||
var.total = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.VAR = var;
|
||||
} else if (register_data.type == REACTIVE_POWER_VAR_L1) {
|
||||
types::units::ReactivePower var = this->pm_last_values.VAR.value();
|
||||
var.L1 = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.VAR = var;
|
||||
} else if (register_data.type == REACTIVE_POWER_VAR_L2) {
|
||||
types::units::ReactivePower var = this->pm_last_values.VAR.value();
|
||||
var.L2 = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.VAR = var;
|
||||
} else if (register_data.type == REACTIVE_POWER_VAR_L3) {
|
||||
types::units::ReactivePower var = this->pm_last_values.VAR.value();
|
||||
var.L3 = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.VAR = var;
|
||||
} else if (register_data.type == CURRENT_A_DC) {
|
||||
types::units::Current amp = this->pm_last_values.current_A.value();
|
||||
amp.DC = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.current_A = amp;
|
||||
} else if (register_data.type == CURRENT_A_L1) {
|
||||
types::units::Current amp = this->pm_last_values.current_A.value();
|
||||
amp.L1 = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.current_A = amp;
|
||||
} else if (register_data.type == CURRENT_A_L2) {
|
||||
types::units::Current amp = this->pm_last_values.current_A.value();
|
||||
amp.L2 = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.current_A = amp;
|
||||
} else if (register_data.type == CURRENT_A_L3) {
|
||||
types::units::Current amp = this->pm_last_values.current_A.value();
|
||||
amp.L3 = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.current_A = amp;
|
||||
} else if (register_data.type == FREQUENCY_HZ_L1) {
|
||||
types::units::Frequency freq = this->pm_last_values.frequency_Hz.value();
|
||||
freq.L1 = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.frequency_Hz = freq;
|
||||
} else if (register_data.type == FREQUENCY_HZ_L2) {
|
||||
types::units::Frequency freq = this->pm_last_values.frequency_Hz.value();
|
||||
freq.L2 = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.frequency_Hz = freq;
|
||||
} else if (register_data.type == FREQUENCY_HZ_L3) {
|
||||
types::units::Frequency freq = this->pm_last_values.frequency_Hz.value();
|
||||
freq.L3 = this->merge_register_values_into_element(register_data, exponent, register_message);
|
||||
this->pm_last_values.frequency_Hz = freq;
|
||||
} else {
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
float powermeterImpl::merge_register_values_into_element(const RegisterData& reg_data, const int16_t exponent,
|
||||
const types::serial_comm_hub_requests::Result& reg_message) {
|
||||
uint32_t value{0};
|
||||
const auto& reg_value = reg_message.value.value();
|
||||
if (reg_data.num_registers == 1 && reg_value.size() == 1) {
|
||||
value = reg_value.at(0);
|
||||
} else if (reg_data.num_registers == 2 && reg_value.size() == 2) {
|
||||
value += reg_value.at(0) << 16;
|
||||
value += reg_value.at(1);
|
||||
} else {
|
||||
throw std::runtime_error("Values of more than 2 registers in size are currently not supported!");
|
||||
}
|
||||
|
||||
const auto val = *reinterpret_cast<float*>(&value);
|
||||
const auto val_scaled = float(val * reg_data.multiplier * pow(10.0, exponent));
|
||||
|
||||
return val_scaled;
|
||||
}
|
||||
|
||||
void powermeterImpl::output_error_with_content(const types::serial_comm_hub_requests::Result& response) {
|
||||
std::stringstream ss;
|
||||
|
||||
if (response.value) {
|
||||
for (size_t i = 0; i < response.value->size(); i++) {
|
||||
if (i != 0)
|
||||
ss << ", ";
|
||||
ss << "0x" << std::setfill('0') << std::setw(2) << std::hex << int(response.value.value()[i]);
|
||||
}
|
||||
}
|
||||
|
||||
EVLOG_debug << "received error response: " << status_code_enum_to_string(response.status_code) << " (" << ss.str()
|
||||
<< ")";
|
||||
}
|
||||
|
||||
} // namespace main
|
||||
} // namespace module
|
||||
@@ -0,0 +1,142 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
// Copyright Pionix GmbH and Contributors to EVerest
|
||||
#ifndef MAIN_POWERMETER_IMPL_HPP
|
||||
#define MAIN_POWERMETER_IMPL_HPP
|
||||
|
||||
//
|
||||
// AUTO GENERATED - MARKED REGIONS WILL BE KEPT
|
||||
// template version 3
|
||||
//
|
||||
|
||||
#include <generated/interfaces/powermeter/Implementation.hpp>
|
||||
|
||||
#include "../GenericPowermeter.hpp"
|
||||
|
||||
// ev@75ac1216-19eb-4182-a85c-820f1fc2c091:v1
|
||||
// insert your custom include headers here
|
||||
#include <optional>
|
||||
#include <string>
|
||||
// ev@75ac1216-19eb-4182-a85c-820f1fc2c091:v1
|
||||
|
||||
namespace module {
|
||||
namespace main {
|
||||
|
||||
struct Conf {
|
||||
std::string model;
|
||||
int powermeter_device_id;
|
||||
int modbus_base_address;
|
||||
};
|
||||
|
||||
class powermeterImpl : public powermeterImplBase {
|
||||
public:
|
||||
powermeterImpl() = delete;
|
||||
powermeterImpl(Everest::ModuleAdapter* ev, const Everest::PtrContainer<GenericPowermeter>& mod, Conf& config) :
|
||||
powermeterImplBase(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:
|
||||
// command handler functions (virtual)
|
||||
virtual types::powermeter::TransactionStartResponse
|
||||
handle_start_transaction(types::powermeter::TransactionReq& value) override;
|
||||
virtual types::powermeter::TransactionStopResponse handle_stop_transaction(std::string& transaction_id) override;
|
||||
|
||||
// ev@d2d1847a-7b88-41dd-ad07-92785f06f5c4:v1
|
||||
// insert your protected definitions here
|
||||
// ev@d2d1847a-7b88-41dd-ad07-92785f06f5c4:v1
|
||||
|
||||
private:
|
||||
const Everest::PtrContainer<GenericPowermeter>& mod;
|
||||
const Conf& config;
|
||||
|
||||
virtual void init() override;
|
||||
virtual void ready() override;
|
||||
|
||||
// ev@3370e4dd-95f4-47a9-aaec-ea76f34a66c9:v1
|
||||
enum PowermeterRegisters {
|
||||
// do not change order or index of these elements!
|
||||
ENERGY_WH_IMPORT_TOTAL,
|
||||
ENERGY_WH_IMPORT_L1,
|
||||
ENERGY_WH_IMPORT_L2,
|
||||
ENERGY_WH_IMPORT_L3,
|
||||
ENERGY_WH_EXPORT_TOTAL,
|
||||
ENERGY_WH_EXPORT_L1,
|
||||
ENERGY_WH_EXPORT_L2,
|
||||
ENERGY_WH_EXPORT_L3,
|
||||
POWER_W_TOTAL,
|
||||
POWER_W_L1,
|
||||
POWER_W_L2,
|
||||
POWER_W_L3,
|
||||
VOLTAGE_V_DC,
|
||||
VOLTAGE_V_L1,
|
||||
VOLTAGE_V_L2,
|
||||
VOLTAGE_V_L3,
|
||||
REACTIVE_POWER_VAR_TOTAL,
|
||||
REACTIVE_POWER_VAR_L1,
|
||||
REACTIVE_POWER_VAR_L2,
|
||||
REACTIVE_POWER_VAR_L3,
|
||||
CURRENT_A_DC,
|
||||
CURRENT_A_L1,
|
||||
CURRENT_A_L2,
|
||||
CURRENT_A_L3,
|
||||
FREQUENCY_HZ_L1,
|
||||
FREQUENCY_HZ_L2,
|
||||
FREQUENCY_HZ_L3,
|
||||
NUM_PM_REGISTERS
|
||||
};
|
||||
|
||||
enum ModbusFunctionType {
|
||||
READ_HOLDING_REGISTER,
|
||||
READ_INPUT_REGISTER,
|
||||
REGISTER_TYPE_UNDEFINED
|
||||
};
|
||||
|
||||
struct RegisterData {
|
||||
float multiplier;
|
||||
PowermeterRegisters type;
|
||||
uint16_t start_register;
|
||||
ModbusFunctionType start_register_function;
|
||||
uint16_t exponent_register;
|
||||
ModbusFunctionType exponent_register_function;
|
||||
uint16_t num_registers;
|
||||
};
|
||||
|
||||
std::vector<RegisterData> pm_configuration;
|
||||
|
||||
types::powermeter::Powermeter pm_last_values;
|
||||
|
||||
std::thread output_thread;
|
||||
|
||||
/// @brief Remember whether we already logged the meter's unavailability.
|
||||
bool meter_is_unavailable{false};
|
||||
|
||||
void init_default_values();
|
||||
void init_register_assignments(const json& loaded_registers);
|
||||
bool assign_register_data(const json& registers, const PowermeterRegisters register_type,
|
||||
const std::string& register_selector);
|
||||
void assign_register_sublevel_data(const json& registers, const PowermeterRegisters& register_type,
|
||||
const std::string& register_selector, const std::string& sublevel_selector,
|
||||
const uint8_t offset);
|
||||
powermeterImpl::ModbusFunctionType select_modbus_function(const uint8_t function_code);
|
||||
void read_powermeter_values();
|
||||
bool read_register(const RegisterData& register_config);
|
||||
bool process_response(
|
||||
const RegisterData& register_data, const types::serial_comm_hub_requests::Result& register_message,
|
||||
std::optional<std::reference_wrapper<const types::serial_comm_hub_requests::Result>> exponent_message);
|
||||
float merge_register_values_into_element(const RegisterData& reg_data, const int16_t exponent,
|
||||
const types::serial_comm_hub_requests::Result& reg_message);
|
||||
void process_current_rate_message(const types::serial_comm_hub_requests::Result message);
|
||||
void output_error_with_content(const types::serial_comm_hub_requests::Result& response);
|
||||
// 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_POWERMETER_IMPL_HPP
|
||||
Reference in New Issue
Block a user