EVSE Delegate callbacks to user application

examples/all-clusters-app/all-clusters-common/all-clusters-app.matter

@@ -7354,6 +7354,15 @@ endpoint 1 {
     callback attribute attributeList;
     ram      attribute featureMap default = 0;
     ram      attribute clusterRevision default = 2;
+
+    handle command GetTargetsResponse;
+    handle command Disable;
+    handle command EnableCharging;
+    handle command EnableDischarging;
+    handle command StartDiagnostics;
+    handle command SetTargets;
+    handle command GetTargets;
+    handle command ClearTargets;
   }
 
   server cluster WindowCovering {

examples/all-clusters-app/all-clusters-common/all-clusters-app.zap

@@ -11737,6 +11737,72 @@
           "side": "server",
           "enabled": 1,
           "apiMaturity": "provisional",
+          "commands": [
+            {
+              "name": "GetTargetsResponse",
+              "code": 0,
+              "mfgCode": null,
+              "source": "server",
+              "isIncoming": 0,
+              "isEnabled": 1
+            },
+            {
+              "name": "Disable",
+              "code": 1,
+              "mfgCode": null,
+              "source": "client",
+              "isIncoming": 1,
+              "isEnabled": 1
+            },
+            {
+              "name": "EnableCharging",
+              "code": 2,
+              "mfgCode": null,
+              "source": "client",
+              "isIncoming": 1,
+              "isEnabled": 1
+            },
+            {
+              "name": "EnableDischarging",
+              "code": 3,
+              "mfgCode": null,
+              "source": "client",
+              "isIncoming": 1,
+              "isEnabled": 1
+            },
+            {
+              "name": "StartDiagnostics",
+              "code": 4,
+              "mfgCode": null,
+              "source": "client",
+              "isIncoming": 1,
+              "isEnabled": 1
+            },
+            {
+              "name": "SetTargets",
+              "code": 5,
+              "mfgCode": null,
+              "source": "client",
+              "isIncoming": 1,
+              "isEnabled": 1
+            },
+            {
+              "name": "GetTargets",
+              "code": 6,
+              "mfgCode": null,
+              "source": "client",
+              "isIncoming": 1,
+              "isEnabled": 1
+            },
+            {
+              "name": "ClearTargets",
+              "code": 7,
+              "mfgCode": null,
+              "source": "client",
+              "isIncoming": 1,
+              "isEnabled": 1
+            }
+          ],
           "attributes": [
             {
               "name": "State",

examples/all-clusters-app/all-clusters-common/include/EVSECallbacks.h

@@ -0,0 +1,84 @@
+/*
+ *
+ *    Copyright (c) 2023 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.
+ */
+
+#pragma once
+
+namespace chip {
+namespace app {
+namespace Clusters {
+
+using namespace chip::app::Clusters::EnergyEvse;
+
+/* This callbacks mechanism is intended to allow different delegates to
+ * dispatch notifications that something has changed.
+ *
+ * This is not specific to the EnergyEVSE cluster, but includes DeviceEnergyManagement
+ * and potential future clusters.
+ */
+enum EVSECallbackType
+{
+    /*
+     * The State has changed (e.g. from Disabled to Charging, or vice-versa)
+     */
+    StateChanged,
+    /*
+     * ChargeCurrent has changed
+     */
+    ChargeCurrentChanged,
+    /*
+     * Charging Preferences have changed
+     */
+    ChargingPreferencesChanged,
+    /*
+     * DeviceEnergyManagement has changed
+     */
+    DeviceEnergyManagementChanged,
+};
+
+struct EVSECbInfo
+{
+    EVSECallbackType type;
+
+    union
+    {
+        /* for type = StateChanged */
+        struct
+        {
+            StateEnum state;
+            SupplyStateEnum supplyState;
+        } StateChange;
+
+        /* for type = ChargeCurrentChanged */
+        struct
+        {
+            int64_t maximumChargeCurrent;
+        } ChargingCurrent;
+    };
+};
+
+typedef void (*EVSECallbackFunc)(const EVSECbInfo * cb, intptr_t arg);
+
+struct EVSECallbackWrapper
+{
+    EVSECallbackFunc handler;
+    intptr_t arg;
+};
+
+} // namespace Clusters
+} // namespace app
+} // namespace chip

examples/all-clusters-app/all-clusters-common/include/EnergyEvseDelegateImpl.h

@@ -19,6 +19,7 @@
 #pragma once
 
 #include "app/clusters/energy-evse-server/energy-evse-server.h"
+#include <EVSECallbacks.h>
 
 #include <app/util/af.h>
 #include <app/util/config.h>
@@ -68,9 +69,13 @@ class EnergyEvseDelegate : public EnergyEvse::Delegate
      */
     Status StartDiagnostics() override;
 
+    /**
+     * @brief    Called by EVSE Hardware to register a single callback handler
+     */
+    Status HwRegisterEvseCallbackHandler(EVSECallbackFunc handler, intptr_t arg);
+
     // -----------------------------------------------------------------
     // Internal API to allow an EVSE to change its internal state etc
-    // TODO Status HwRegisterEvseHardwareCallback(Callback);
     Status HwSetMaxHardwareCurrentLimit(int64_t currentmA);
     Status HwSetCircuitCapacity(int64_t currentmA);
     Status HwSetCableAssemblyLimit(int64_t currentmA);
@@ -150,6 +155,11 @@ class EnergyEvseDelegate : public EnergyEvse::Delegate
     int64_t mActualChargingCurrentLimit             = 0;
     StateEnum mHwState                              = StateEnum::kNotPluggedIn; /* Hardware state */
 
+    /* Callback related */
+    EVSECallbackWrapper mCallbacks = { .handler = nullptr, .arg = 0 }; /* Wrapper to allow callbacks to be registered */
+    Status NotifyApplicationCurrentLimitChange(int64_t maximumChargeCurrent);
+    Status NotifyApplicationStateChange();
+
     /**
      * @brief Helper function to work out the charge limit based on conditions and settings
      */

examples/all-clusters-app/all-clusters-common/src/EnergyEvseDelegateImpl.cpp

@@ -83,6 +83,7 @@ Status EnergyEvseDelegate::Disable()
     /* update MaximumDischargeCurrent to 0 */
     SetMaximumDischargeCurrent(0);
 
+    NotifyApplicationStateChange();
     // TODO: Generate events
 
     return Status::Success;
@@ -102,31 +103,31 @@ Status EnergyEvseDelegate::EnableCharging(const DataModel::Nullable<uint32_t> &
 
     if (maximumChargeCurrent < kMinimumChargeCurrent || maximumChargeCurrent > kMaximumChargeCurrent)
     {
-        ChipLogError(NotSpecified, "Maximum Current outside limits");
+        ChipLogError(AppServer, "Maximum Current outside limits");
         return Status::ConstraintError;
     }
 
     if (minimumChargeCurrent < kMinimumChargeCurrent || minimumChargeCurrent > kMaximumChargeCurrent)
     {
-        ChipLogError(NotSpecified, "Maximum Current outside limits");
+        ChipLogError(AppServer, "Maximum Current outside limits");
         return Status::ConstraintError;
     }
 
     if (minimumChargeCurrent > maximumChargeCurrent)
     {
-        ChipLogError(NotSpecified, "Minium Current > Maximum Current!");
+        ChipLogError(AppServer, "Minium Current > Maximum Current!");
         return Status::ConstraintError;
     }
 
     if (chargingEnabledUntil.IsNull())
     {
         /* Charging enabled indefinitely */
-        ChipLogError(NotSpecified, "Charging enabled indefinitely");
+        ChipLogError(AppServer, "Charging enabled indefinitely");
     }
     else
     {
         /* check chargingEnabledUntil is in the future */
-        ChipLogError(NotSpecified, "Charging enabled until: %lu", static_cast<long unsigned int>(chargingEnabledUntil.Value()));
+        ChipLogError(AppServer, "Charging enabled until: %lu", static_cast<long unsigned int>(chargingEnabledUntil.Value()));
         // TODO
         // if (checkChargingEnabled)
     }
@@ -169,6 +170,8 @@ Status EnergyEvseDelegate::EnableCharging(const DataModel::Nullable<uint32_t> &
 
     // TODO: Generate events
 
+    NotifyApplicationStateChange();
+
     return this->ComputeMaxChargeCurrentLimit();
 }
 
@@ -188,6 +191,8 @@ Status EnergyEvseDelegate::EnableDischarging(const DataModel::Nullable<uint32_t>
 
     // TODO: Generate events
 
+    NotifyApplicationStateChange();
+
     return Status::Success;
 }
 
@@ -199,25 +204,42 @@ Status EnergyEvseDelegate::StartDiagnostics()
     /* For EVSE manufacturers to customize */
     ChipLogProgress(AppServer, "EnergyEvseDelegate::StartDiagnostics()");
 
-    /* update SupplyState */
+    /* update SupplyState to indicate we are now in Diagnostics mode */
     SetSupplyState(SupplyStateEnum::kDisabledDiagnostics);
 
     // TODO: Generate events
 
+    // TODO: Notify Application to implement Diagnostics
+
+    NotifyApplicationStateChange();
+
     return Status::Success;
 }
 
 /* ---------------------------------------------------------------------------
- * FUNCTIONS BELOW:
- *    - EVSE Hardware interface
+ *  EVSE Hardware interface below
+ */
+
+/**
+ * @brief    Called by EVSE Hardware to register a callback handler mechanism
  *
- *  SetMaxHardwareCurrentLimit( currentmA )
- *  SetCircuitCapacity( currentmA )
- *  SetCableAssemblyLimit( currentmA )
- *  SetState( EVSEStateEnum )
- *  SetFault
+ *           This is normally called at start-up.
  *
+ * @param    EVSECallbackFunct - function pointer to call
+ * @param    intptr_t          - optional context to provide back to callback handler
  */
+Status EnergyEvseDelegate::HwRegisterEvseCallbackHandler(EVSECallbackFunc handler, intptr_t arg)
+{
+    if (mCallbacks.handler != nullptr)
+    {
+        ChipLogError(AppServer, "Callback handler already initialized");
+        return Status::Failure;
+    }
+    mCallbacks.handler = handler;
+    mCallbacks.arg     = arg;
+
+    return Status::Success;
+}
 
 /**
  * @brief    Called by EVSE Hardware to notify the delegate of the maximum
@@ -420,17 +442,18 @@ Status EnergyEvseDelegate::HwSetVehicleID(const CharSpan & newValue)
 
 /**
  *  @brief   Called to compute the safe charging current limit
+ *
+ * mActualChargingCurrentLimit is the minimum of:
+ *   - MaxHardwareCurrentLimit (of the hardware)
+ *   - CircuitCapacity (set by the electrician - less than the hardware)
+ *   - CableAssemblyLimit (detected when the cable is inserted)
+ *   - MaximumChargeCurrent (from charging command)
+ *   - UserMaximumChargeCurrent (could dynamically change)
+ *
  */
 Status EnergyEvseDelegate::ComputeMaxChargeCurrentLimit()
 {
     int64_t oldValue;
-    /* mActualChargingCurrentLimit is the minimum of:
-     *   - MaxHardwareCurrentLimit (of the hardware)
-     *   - CircuitCapacity (set by the electrician - less than the hardware)
-     *   - CableAssemblyLimit (detected when the cable is inserted)
-     *   - MaximumChargeCurrent (from charging command)
-     *   - UserMaximumChargeCurrent (could dynamically change)
-     */
 
     oldValue                    = mActualChargingCurrentLimit;
     mActualChargingCurrentLimit = mMaxHardwareCurrentLimit;
@@ -448,11 +471,42 @@ Status EnergyEvseDelegate::ComputeMaxChargeCurrentLimit()
         MatterReportingAttributeChangeCallback(mEndpointId, EnergyEvse::Id, MaximumChargeCurrent::Id);
 
         /* Call the EV Charger hardware current limit callback */
-        // TODO
+        NotifyApplicationCurrentLimitChange(mMaximumChargeCurrent);
     }
     return Status::Success;
 }
 
+Status EnergyEvseDelegate::NotifyApplicationCurrentLimitChange(int64_t maximumChargeCurrent)
+{
+    EVSECbInfo cbInfo;
+
+    cbInfo.type                                 = EVSECallbackType::ChargeCurrentChanged;
+    cbInfo.ChargingCurrent.maximumChargeCurrent = maximumChargeCurrent;
+
+    if (mCallbacks.handler != nullptr)
+    {
+        mCallbacks.handler(&cbInfo, mCallbacks.arg);
+    }
+
+    return Status::Success;
+}
+
+Status EnergyEvseDelegate::NotifyApplicationStateChange()
+{
+    EVSECbInfo cbInfo;
+
+    cbInfo.type                    = EVSECallbackType::StateChanged;
+    cbInfo.StateChange.state       = mState;
+    cbInfo.StateChange.supplyState = mSupplyState;
+
+    if (mCallbacks.handler != nullptr)
+    {
+        mCallbacks.handler(&cbInfo, mCallbacks.arg);
+    }
+
+    return Status::Success;
+}
+
 /**
  * Attribute methods
  */