blob: 9beff80e8dc22afc9e35127e4a96c61cf1dd4add [file] [log] [blame]
/*
*
* Copyright (c) 2024 Project CHIP Authors
* All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <DeviceEnergyManagementManager.h>
#include <EVSEManufacturerImpl.h>
#include <ElectricalPowerMeasurementDelegate.h>
#include <EnergyEvseManager.h>
#include <device-energy-management-modes.h>
#include <energy-evse-modes.h>
#include <app-common/zap-generated/ids/Attributes.h>
#include <app-common/zap-generated/ids/Clusters.h>
#include <app/ConcreteAttributePath.h>
#include <app/clusters/electrical-energy-measurement-server/electrical-energy-measurement-server.h>
#include <app/clusters/network-commissioning/network-commissioning.h>
#include <app/server/Server.h>
#include <lib/support/logging/CHIPLogging.h>
#include <platform/Linux/NetworkCommissioningDriver.h>
#define ENERGY_EVSE_ENDPOINT 1
using namespace chip;
using namespace chip::app;
using namespace chip::app::DataModel;
using namespace chip::app::Clusters;
using namespace chip::app::Clusters::EnergyEvse;
using namespace chip::app::Clusters::DeviceEnergyManagement;
using namespace chip::app::Clusters::ElectricalPowerMeasurement;
using namespace chip::app::Clusters::ElectricalEnergyMeasurement;
static std::unique_ptr<EnergyEvseDelegate> gEvseDelegate;
static std::unique_ptr<EnergyEvseManager> gEvseInstance;
static std::unique_ptr<DeviceEnergyManagementDelegate> gDEMDelegate;
static std::unique_ptr<DeviceEnergyManagementManager> gDEMInstance;
static std::unique_ptr<EVSEManufacturer> gEvseManufacturer;
static std::unique_ptr<ElectricalPowerMeasurementDelegate> gEPMDelegate;
static std::unique_ptr<ElectricalPowerMeasurementInstance> gEPMInstance;
// Electrical Energy Measurement cluster uses ember to initialise
static std::unique_ptr<ElectricalEnergyMeasurementAttrAccess> gEEMAttrAccess;
EVSEManufacturer * EnergyEvse::GetEvseManufacturer()
{
return gEvseManufacturer.get();
}
/*
* @brief Creates a Delegate and Instance for DEM
*
* The Instance is a container around the Delegate, so
* create the Delegate first, then wrap it in the Instance
* Then call the Instance->Init() to register the attribute and command handlers
*/
CHIP_ERROR DeviceEnergyManagementInit()
{
if (gDEMDelegate || gDEMInstance)
{
ChipLogError(AppServer, "DEM Instance or Delegate already exist.");
return CHIP_ERROR_INCORRECT_STATE;
}
gDEMDelegate = std::make_unique<DeviceEnergyManagementDelegate>();
if (!gDEMDelegate)
{
ChipLogError(AppServer, "Failed to allocate memory for DeviceEnergyManagementDelegate");
return CHIP_ERROR_NO_MEMORY;
}
/* Manufacturer may optionally not support all features, commands & attributes */
gDEMInstance = std::make_unique<DeviceEnergyManagementManager>(
EndpointId(ENERGY_EVSE_ENDPOINT), *gDEMDelegate,
BitMask<DeviceEnergyManagement::Feature, uint32_t>(
DeviceEnergyManagement::Feature::kPowerAdjustment, DeviceEnergyManagement::Feature::kPowerForecastReporting,
DeviceEnergyManagement::Feature::kStateForecastReporting, DeviceEnergyManagement::Feature::kStartTimeAdjustment,
DeviceEnergyManagement::Feature::kPausable));
if (!gDEMInstance)
{
ChipLogError(AppServer, "Failed to allocate memory for DeviceEnergyManagementManager");
gDEMDelegate.reset();
return CHIP_ERROR_NO_MEMORY;
}
CHIP_ERROR err = gDEMInstance->Init(); /* Register Attribute & Command handlers */
if (err != CHIP_NO_ERROR)
{
ChipLogError(AppServer, "Init failed on gDEMInstance");
gDEMInstance.reset();
gDEMDelegate.reset();
return err;
}
return CHIP_NO_ERROR;
}
CHIP_ERROR DeviceEnergyManagementShutdown()
{
/* Do this in the order Instance first, then delegate
* Ensure we call the Instance->Shutdown to free attribute & command handlers first
*/
if (gDEMInstance)
{
/* deregister attribute & command handlers */
gDEMInstance->Shutdown();
gDEMInstance.reset();
}
if (gDEMDelegate)
{
gDEMDelegate.reset();
}
return CHIP_NO_ERROR;
}
/*
* @brief Creates a Delegate and Instance for EVSE cluster
*
* The Instance is a container around the Delegate, so
* create the Delegate first, then wrap it in the Instance
* Then call the Instance->Init() to register the attribute and command handlers
*/
CHIP_ERROR EnergyEvseInit()
{
CHIP_ERROR err;
if (gEvseDelegate || gEvseInstance)
{
ChipLogError(AppServer, "EVSE Instance or Delegate already exist.");
return CHIP_ERROR_INCORRECT_STATE;
}
gEvseDelegate = std::make_unique<EnergyEvseDelegate>();
if (!gEvseDelegate)
{
ChipLogError(AppServer, "Failed to allocate memory for EnergyEvseDelegate");
return CHIP_ERROR_NO_MEMORY;
}
/* Manufacturer may optionally not support all features, commands & attributes */
gEvseInstance = std::make_unique<EnergyEvseManager>(
EndpointId(ENERGY_EVSE_ENDPOINT), *gEvseDelegate,
BitMask<EnergyEvse::Feature, uint32_t>(EnergyEvse::Feature::kChargingPreferences, EnergyEvse::Feature::kRfid),
BitMask<EnergyEvse::OptionalAttributes, uint32_t>(EnergyEvse::OptionalAttributes::kSupportsUserMaximumChargingCurrent,
EnergyEvse::OptionalAttributes::kSupportsRandomizationWindow,
EnergyEvse::OptionalAttributes::kSupportsApproximateEvEfficiency),
BitMask<EnergyEvse::OptionalCommands, uint32_t>(EnergyEvse::OptionalCommands::kSupportsStartDiagnostics));
if (!gEvseInstance)
{
ChipLogError(AppServer, "Failed to allocate memory for EnergyEvseManager");
gEvseDelegate.reset();
return CHIP_ERROR_NO_MEMORY;
}
err = gEvseInstance->Init(); /* Register Attribute & Command handlers */
if (err != CHIP_NO_ERROR)
{
ChipLogError(AppServer, "Init failed on gEvseInstance");
gEvseInstance.reset();
gEvseDelegate.reset();
return err;
}
return CHIP_NO_ERROR;
}
CHIP_ERROR EnergyEvseShutdown()
{
/* Do this in the order Instance first, then delegate
* Ensure we call the Instance->Shutdown to free attribute & command handlers first
*/
if (gEvseInstance)
{
/* deregister attribute & command handlers */
gEvseInstance->Shutdown();
gEvseInstance.reset();
}
if (gEvseDelegate)
{
gEvseDelegate.reset();
}
return CHIP_NO_ERROR;
}
/*
* @brief Creates a Delegate and Instance for Electrical Power/Energy Measurement clusters
*
* The Instance is a container around the Delegate, so
* create the Delegate first, then wrap it in the Instance
* Then call the Instance->Init() to register the attribute and command handlers
*/
CHIP_ERROR EnergyMeterInit()
{
CHIP_ERROR err;
if (gEPMDelegate || gEPMInstance)
{
ChipLogError(AppServer, "EPM Instance or Delegate already exist.");
return CHIP_ERROR_INCORRECT_STATE;
}
gEPMDelegate = std::make_unique<ElectricalPowerMeasurementDelegate>();
if (!gEPMDelegate)
{
ChipLogError(AppServer, "Failed to allocate memory for EPM Delegate");
return CHIP_ERROR_NO_MEMORY;
}
/* Manufacturer may optionally not support all features, commands & attributes */
/* Turning on all optional features and attributes for test certification purposes */
gEPMInstance = std::make_unique<ElectricalPowerMeasurementInstance>(
EndpointId(ENERGY_EVSE_ENDPOINT), *gEPMDelegate,
BitMask<ElectricalPowerMeasurement::Feature, uint32_t>(
ElectricalPowerMeasurement::Feature::kDirectCurrent, ElectricalPowerMeasurement::Feature::kAlternatingCurrent,
ElectricalPowerMeasurement::Feature::kPolyphasePower, ElectricalPowerMeasurement::Feature::kHarmonics,
ElectricalPowerMeasurement::Feature::kPowerQuality),
BitMask<ElectricalPowerMeasurement::OptionalAttributes, uint32_t>(
ElectricalPowerMeasurement::OptionalAttributes::kOptionalAttributeRanges,
ElectricalPowerMeasurement::OptionalAttributes::kOptionalAttributeVoltage,
ElectricalPowerMeasurement::OptionalAttributes::kOptionalAttributeActiveCurrent,
ElectricalPowerMeasurement::OptionalAttributes::kOptionalAttributeReactiveCurrent,
ElectricalPowerMeasurement::OptionalAttributes::kOptionalAttributeApparentCurrent,
ElectricalPowerMeasurement::OptionalAttributes::kOptionalAttributeReactivePower,
ElectricalPowerMeasurement::OptionalAttributes::kOptionalAttributeApparentPower,
ElectricalPowerMeasurement::OptionalAttributes::kOptionalAttributeRMSVoltage,
ElectricalPowerMeasurement::OptionalAttributes::kOptionalAttributeRMSCurrent,
ElectricalPowerMeasurement::OptionalAttributes::kOptionalAttributeRMSPower,
ElectricalPowerMeasurement::OptionalAttributes::kOptionalAttributeFrequency,
ElectricalPowerMeasurement::OptionalAttributes::kOptionalAttributePowerFactor,
ElectricalPowerMeasurement::OptionalAttributes::kOptionalAttributeNeutralCurrent));
if (!gEPMInstance)
{
ChipLogError(AppServer, "Failed to allocate memory for EPM Instance");
gEPMDelegate.reset();
return CHIP_ERROR_NO_MEMORY;
}
err = gEPMInstance->Init(); /* Register Attribute & Command handlers */
if (err != CHIP_NO_ERROR)
{
ChipLogError(AppServer, "Init failed on gEPMInstance");
gEPMInstance.reset();
gEPMDelegate.reset();
return err;
}
return CHIP_NO_ERROR;
}
CHIP_ERROR EnergyMeterShutdown()
{
/* Do this in the order Instance first, then delegate
* Ensure we call the Instance->Shutdown to free attribute & command handlers first
*/
if (gEPMInstance)
{
/* deregister attribute & command handlers */
gEPMInstance->Shutdown();
gEPMInstance.reset();
}
if (gEPMDelegate)
{
gEPMDelegate.reset();
}
return CHIP_NO_ERROR;
}
/*
* @brief Creates a EVSEManufacturer class to hold the EVSE & DEM clusters
*
* The Instance is a container around the Delegate, so
* create the Delegate first, then wrap it in the Instance
* Then call the Instance->Init() to register the attribute and command handlers
*/
CHIP_ERROR EVSEManufacturerInit()
{
CHIP_ERROR err;
if (gEvseManufacturer)
{
ChipLogError(AppServer, "EvseManufacturer already exist.");
return CHIP_ERROR_INCORRECT_STATE;
}
/* Now create EVSEManufacturer */
gEvseManufacturer = std::make_unique<EVSEManufacturer>(gEvseInstance.get(), gEPMInstance.get());
if (!gEvseManufacturer)
{
ChipLogError(AppServer, "Failed to allocate memory for EvseManufacturer");
return CHIP_ERROR_NO_MEMORY;
}
/* Call Manufacturer specific init */
err = gEvseManufacturer->Init();
if (err != CHIP_NO_ERROR)
{
ChipLogError(AppServer, "Init failed on gEvseManufacturer");
gEvseManufacturer.reset();
return err;
}
return CHIP_NO_ERROR;
}
CHIP_ERROR EVSEManufacturerShutdown()
{
if (gEvseManufacturer)
{
/* Shutdown the EVSEManufacturer */
gEvseManufacturer->Shutdown();
gEvseManufacturer.reset();
}
return CHIP_NO_ERROR;
}
void EvseApplicationInit()
{
if (DeviceEnergyManagementInit() != CHIP_NO_ERROR)
{
return;
}
if (EnergyEvseInit() != CHIP_NO_ERROR)
{
DeviceEnergyManagementShutdown();
return;
}
if (EnergyMeterInit() != CHIP_NO_ERROR)
{
DeviceEnergyManagementShutdown();
EnergyEvseShutdown();
return;
}
if (EVSEManufacturerInit() != CHIP_NO_ERROR)
{
DeviceEnergyManagementShutdown();
EnergyEvseShutdown();
EnergyMeterShutdown();
return;
}
}
void EvseApplicationShutdown()
{
ChipLogDetail(AppServer, "Energy Management App: ApplicationShutdown()");
/* Shutdown in reverse order that they were created */
EVSEManufacturerShutdown(); /* Free the EVSEManufacturer */
EnergyMeterShutdown(); /* Free the Energy Meter */
EnergyEvseShutdown(); /* Free the EnergyEvse */
DeviceEnergyManagementShutdown(); /* Free the DEM */
Clusters::DeviceEnergyManagementMode::Shutdown();
Clusters::EnergyEvseMode::Shutdown();
}
void emberAfElectricalEnergyMeasurementClusterInitCallback(chip::EndpointId endpointId)
{
VerifyOrDie(endpointId == 1); // this cluster is only enabled for endpoint 1.
VerifyOrDie(!gEEMAttrAccess);
gEEMAttrAccess = std::make_unique<ElectricalEnergyMeasurementAttrAccess>(
BitMask<ElectricalEnergyMeasurement::Feature, uint32_t>(
ElectricalEnergyMeasurement::Feature::kImportedEnergy, ElectricalEnergyMeasurement::Feature::kExportedEnergy,
ElectricalEnergyMeasurement::Feature::kCumulativeEnergy, ElectricalEnergyMeasurement::Feature::kPeriodicEnergy),
BitMask<ElectricalEnergyMeasurement::OptionalAttributes, uint32_t>(
ElectricalEnergyMeasurement::OptionalAttributes::kOptionalAttributeCumulativeEnergyReset));
// Create an accuracy entry which is between +/-0.5 and +/- 5% across the range of all possible energy readings
ElectricalEnergyMeasurement::Structs::MeasurementAccuracyRangeStruct::Type energyAccuracyRanges[] = {
{ .rangeMin = 0,
.rangeMax = 1'000'000'000'000'000, // 1 million Mwh
.percentMax = MakeOptional(static_cast<chip::Percent100ths>(500)),
.percentMin = MakeOptional(static_cast<chip::Percent100ths>(50)) }
};
ElectricalEnergyMeasurement::Structs::MeasurementAccuracyStruct::Type accuracy = {
.measurementType = MeasurementTypeEnum::kElectricalEnergy,
.measured = true,
.minMeasuredValue = 0,
.maxMeasuredValue = 1'000'000'000'000'000, // 1 million Mwh
.accuracyRanges =
DataModel::List<const ElectricalEnergyMeasurement::Structs::MeasurementAccuracyRangeStruct::Type>(energyAccuracyRanges)
};
// Example of setting CumulativeEnergyReset structure - for now set these to 0
// but the manufacturer may want to store these in non volatile storage for timestamp (based on epoch_s)
ElectricalEnergyMeasurement::Structs::CumulativeEnergyResetStruct::Type resetStruct = {
.importedResetTimestamp = MakeOptional(MakeNullable(static_cast<uint32_t>(0))),
.exportedResetTimestamp = MakeOptional(MakeNullable(static_cast<uint32_t>(0))),
.importedResetSystime = MakeOptional(MakeNullable(static_cast<uint64_t>(0))),
.exportedResetSystime = MakeOptional(MakeNullable(static_cast<uint64_t>(0))),
};
if (gEEMAttrAccess)
{
gEEMAttrAccess->Init();
SetMeasurementAccuracy(endpointId, accuracy);
SetCumulativeReset(endpointId, MakeOptional(resetStruct));
}
}