examples/energy-management-app/energy-management-common/src/EnergyEvseMain.cpp - third_party/github/project-chip/connectedhomeip - Git at Google

 /*
  *
  *    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 <PowerTopologyDelegate.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/clusters/power-topology-server/power-topology-server.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;
 using namespace chip::app::Clusters::PowerTopology;

 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;

 static std::unique_ptr<PowerTopologyDelegate> gPTDelegate;
 static std::unique_ptr<PowerTopologyInstance> gPTInstance;

 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 PowerTopology 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 PowerTopologyInit()
 {
     CHIP_ERROR err;

     if (gPTDelegate || gPTInstance)
     {
         ChipLogError(AppServer, "PowerTopology Instance or Delegate already exist.");
         return CHIP_ERROR_INCORRECT_STATE;
     }

     gPTDelegate = std::make_unique<PowerTopologyDelegate>();
     if (!gPTDelegate)
     {
         ChipLogError(AppServer, "Failed to allocate memory for PowerTopology Delegate");
         return CHIP_ERROR_NO_MEMORY;
     }

     gPTInstance =
         std::make_unique<PowerTopologyInstance>(EndpointId(ENERGY_EVSE_ENDPOINT), *gPTDelegate,
                                                 BitMask<PowerTopology::Feature, uint32_t>(PowerTopology::Feature::kNodeTopology),
                                                 BitMask<PowerTopology::OptionalAttributes, uint32_t>(0));

     if (!gPTInstance)
     {
         ChipLogError(AppServer, "Failed to allocate memory for PowerTopology Instance");
         gPTDelegate.reset();
         return CHIP_ERROR_NO_MEMORY;
     }

     err = gPTInstance->Init(); /* Register Attribute & Command handlers */
     if (err != CHIP_NO_ERROR)
     {
         ChipLogError(AppServer, "Init failed on gPTInstance");
         gPTInstance.reset();
         gPTDelegate.reset();
         return err;
     }

     return CHIP_NO_ERROR;
 }

 CHIP_ERROR PowerTopologyShutdown()
 {
     /* Do this in the order Instance first, then delegate
      * Ensure we call the Instance->Shutdown to free attribute & command handlers first
      */
     if (gPTInstance)
     {
         /* deregister attribute & command handlers */
         gPTInstance->Shutdown();
         gPTInstance.reset();
     }

     if (gPTDelegate)
     {
         gPTDelegate.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(), gPTInstance.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 (PowerTopologyInit() != CHIP_NO_ERROR)
     {
         EVSEManufacturerShutdown();
         DeviceEnergyManagementShutdown();
         EnergyEvseShutdown();
         EnergyMeterShutdown();
         return;
     }

     /* Do this last so that the instances for other clusters can be wrapped inside */
     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 */
     PowerTopologyShutdown();          /* Free the PowerTopology */
     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));
     }
 }
	/*
	*
	* 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 <PowerTopologyDelegate.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/clusters/power-topology-server/power-topology-server.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;
	using namespace chip::app::Clusters::PowerTopology;

	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;

	static std::unique_ptr<PowerTopologyDelegate> gPTDelegate;
	static std::unique_ptr<PowerTopologyInstance> gPTInstance;

	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 PowerTopology 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 PowerTopologyInit()
	{
	CHIP_ERROR err;

	if (gPTDelegate \|\| gPTInstance)
	{
	ChipLogError(AppServer, "PowerTopology Instance or Delegate already exist.");
	return CHIP_ERROR_INCORRECT_STATE;
	}

	gPTDelegate = std::make_unique<PowerTopologyDelegate>();
	if (!gPTDelegate)
	{
	ChipLogError(AppServer, "Failed to allocate memory for PowerTopology Delegate");
	return CHIP_ERROR_NO_MEMORY;
	}

	gPTInstance =
	std::make_unique<PowerTopologyInstance>(EndpointId(ENERGY_EVSE_ENDPOINT), *gPTDelegate,
	BitMask<PowerTopology::Feature, uint32_t>(PowerTopology::Feature::kNodeTopology),
	BitMask<PowerTopology::OptionalAttributes, uint32_t>(0));

	if (!gPTInstance)
	{
	ChipLogError(AppServer, "Failed to allocate memory for PowerTopology Instance");
	gPTDelegate.reset();
	return CHIP_ERROR_NO_MEMORY;
	}

	err = gPTInstance->Init(); /* Register Attribute & Command handlers */
	if (err != CHIP_NO_ERROR)
	{
	ChipLogError(AppServer, "Init failed on gPTInstance");
	gPTInstance.reset();
	gPTDelegate.reset();
	return err;
	}

	return CHIP_NO_ERROR;
	}

	CHIP_ERROR PowerTopologyShutdown()
	{
	/* Do this in the order Instance first, then delegate
	* Ensure we call the Instance->Shutdown to free attribute & command handlers first
	*/
	if (gPTInstance)
	{
	/* deregister attribute & command handlers */
	gPTInstance->Shutdown();
	gPTInstance.reset();
	}

	if (gPTDelegate)
	{
	gPTDelegate.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(), gPTInstance.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 (PowerTopologyInit() != CHIP_NO_ERROR)
	{
	EVSEManufacturerShutdown();
	DeviceEnergyManagementShutdown();
	EnergyEvseShutdown();
	EnergyMeterShutdown();
	return;
	}

	/* Do this last so that the instances for other clusters can be wrapped inside */
	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 */
	PowerTopologyShutdown(); /* Free the PowerTopology */
	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));
	}
	}