diff --git a/pid/builder.cpp b/pid/builder.cpp
index 39d0076..d133662 100644
--- a/pid/builder.cpp
+++ b/pid/builder.cpp
@@ -76,7 +76,8 @@
         auto zone = std::make_shared<DbusPidZone>(
             zoneId, zoneConf->second.minThermalOutput,
             zoneConf->second.failsafePercent, zoneConf->second.cycleTime, mgr,
-            modeControlBus, getControlPath(zoneId).c_str(), deferSignals);
+            modeControlBus, getControlPath(zoneId).c_str(), deferSignals,
+            zoneConf->second.accumulateSetPoint);
 
         std::cerr << "Zone Id: " << zone->getZoneID() << "\n";
 
diff --git a/pid/buildjson.cpp b/pid/buildjson.cpp
index dd7d2a3..57fabbf 100644
--- a/pid/buildjson.cpp
+++ b/pid/buildjson.cpp
@@ -66,12 +66,18 @@
      */
     auto p = j.at("pid");
 
+    auto checkHysterWithSetpt = p.find("checkHysterWithSetpt");
     auto positiveHysteresis = p.find("positiveHysteresis");
     auto negativeHysteresis = p.find("negativeHysteresis");
     auto derivativeCoeff = p.find("derivativeCoeff");
+    auto checkHysterWithSetptValue = false;
     auto positiveHysteresisValue = 0.0;
     auto negativeHysteresisValue = 0.0;
     auto derivativeCoeffValue = 0.0;
+    if (checkHysterWithSetpt != p.end())
+    {
+        checkHysterWithSetpt->get_to(checkHysterWithSetptValue);
+    }
     if (positiveHysteresis != p.end())
     {
         positiveHysteresis->get_to(positiveHysteresisValue);
@@ -113,6 +119,7 @@
         c.pidInfo.positiveHysteresis = positiveHysteresisValue;
         c.pidInfo.negativeHysteresis = negativeHysteresisValue;
         c.pidInfo.derivativeCoeff = derivativeCoeffValue;
+        c.pidInfo.checkHysterWithSetpt = checkHysterWithSetptValue;
     }
     else
     {
@@ -213,6 +220,14 @@
         getCycleTimeSetting(zone, id, "updateThermalsTimeMS",
                             thisZoneConfig.cycleTime.updateThermalsTimeMS);
 
+        bool accumulateSetPoint = false;
+        auto findAccSetPoint = zone.find("accumulateSetPoint");
+        if (findAccSetPoint != zone.end())
+        {
+            findAccSetPoint->get_to(accumulateSetPoint);
+        }
+        thisZoneConfig.accumulateSetPoint = accumulateSetPoint;
+
         auto pids = zone["pids"];
         for (const auto& pid : pids)
         {
diff --git a/pid/ec/pid.hpp b/pid/ec/pid.hpp
index 9dac6a4..9db08fd 100644
--- a/pid/ec/pid.hpp
+++ b/pid/ec/pid.hpp
@@ -19,21 +19,23 @@
  */
 typedef struct
 {
-    bool initialized;         // has pid been initialized
+    bool initialized;          // has pid been initialized
+    bool checkHysterWithSetpt; // compare current input and setpoint to check
+                               // hysteresis
 
-    double ts;                // sample time in seconds
-    double integral;          // integral of error
-    double lastOutput;        // value of last output
-    double lastError;         // value of last error
+    double ts;                 // sample time in seconds
+    double integral;           // integral of error
+    double lastOutput;         // value of last output
+    double lastError;          // value of last error
 
-    double proportionalCoeff; // coeff for P
-    double integralCoeff;     // coeff for I
-    double derivativeCoeff;   // coeff for D
-    double feedFwdOffset;     // offset coeff for feed-forward term
-    double feedFwdGain;       // gain for feed-forward term
+    double proportionalCoeff;  // coeff for P
+    double integralCoeff;      // coeff for I
+    double derivativeCoeff;    // coeff for D
+    double feedFwdOffset;      // offset coeff for feed-forward term
+    double feedFwdGain;        // gain for feed-forward term
 
-    limits_t integralLimit;   // clamp of integral
-    limits_t outLim;          // clamp of output
+    limits_t integralLimit;    // clamp of integral
+    limits_t outLim;           // clamp of output
     double slewNeg;
     double slewPos;
     double positiveHysteresis;
@@ -46,6 +48,9 @@
 /* Condensed version for use by the configuration. */
 struct pidinfo
 {
+    bool checkHysterWithSetpt;  // compare current input and setpoint to check
+                                // hysteresis
+
     double ts;                  // sample time in seconds
     double proportionalCoeff;   // coeff for P
     double integralCoeff;       // coeff for I
diff --git a/pid/pidcontroller.cpp b/pid/pidcontroller.cpp
index fa8d6f6..b33037f 100644
--- a/pid/pidcontroller.cpp
+++ b/pid/pidcontroller.cpp
@@ -30,6 +30,81 @@
 namespace pid_control
 {
 
+double PIDController::calPIDOutput(double setpt, double input,
+                                   ec::pid_info_t* info)
+{
+    double output;
+    auto name = getID();
+
+    if (info->checkHysterWithSetpt)
+    {
+        // Over the hysteresis bounds, keep counting pid
+        if (input > (setpt + info->positiveHysteresis))
+        {
+            // Calculate new output
+            output = ec::pid(info, input, setpt, &name);
+
+            // this variable isn't actually used in this context, but we're
+            // setting it here incase somebody uses it later it's the correct
+            // value
+            lastInput = input;
+        }
+        // Under the hysteresis bounds, initialize pid
+        else if (input < (setpt - info->negativeHysteresis))
+        {
+            lastInput = setpt;
+            info->integral = 0;
+            output = 0;
+        }
+        // inside the hysteresis bounds, keep last output
+        else
+        {
+            lastInput = input;
+            output = info->lastOutput;
+        }
+
+        info->lastOutput = output;
+    }
+    else
+    {
+        // if no hysteresis, maintain previous behavior
+        if (info->positiveHysteresis == 0 && info->negativeHysteresis == 0)
+        {
+            // Calculate new output
+            output = ec::pid(info, input, setpt, &name);
+
+            // this variable isn't actually used in this context, but we're
+            // setting it here incase somebody uses it later it's the correct
+            // value
+            lastInput = input;
+        }
+        else
+        {
+            // initialize if the value is not set (NAN) or abnormal (+INF or
+            // -INF)
+            if (!(std::isfinite(lastInput)))
+            {
+                lastInput = input;
+            }
+
+            // if reading is outside of hysteresis bounds, use it for reading,
+            // otherwise use last reading without updating it first
+            else if ((input - lastInput) > info->positiveHysteresis)
+            {
+                lastInput = input;
+            }
+            else if ((lastInput - input) > info->negativeHysteresis)
+            {
+                lastInput = input;
+            }
+
+            output = ec::pid(info, lastInput, setpt, &name);
+        }
+    }
+
+    return output;
+}
+
 void PIDController::process(void)
 {
     double input;
@@ -43,39 +118,11 @@
     input = inputProc();
 
     auto info = getPIDInfo();
-    auto name = getID();
 
-    // if no hysteresis, maintain previous behavior
-    if (info->positiveHysteresis == 0 && info->negativeHysteresis == 0)
-    {
-        // Calculate new output
-        output = ec::pid(info, input, setpt, &name);
+    // Calculate output value
+    output = calPIDOutput(setpt, input, info);
 
-        // this variable isn't actually used in this context, but we're setting
-        // it here incase somebody uses it later it's the correct value
-        lastInput = input;
-    }
-    else
-    {
-        // initialize if not set yet
-        if (std::isnan(lastInput))
-        {
-            lastInput = input;
-        }
-
-        // if reading is outside of hysteresis bounds, use it for reading,
-        // otherwise use last reading without updating it first
-        else if ((input - lastInput) > info->positiveHysteresis)
-        {
-            lastInput = input;
-        }
-        else if ((lastInput - input) > info->negativeHysteresis)
-        {
-            lastInput = input;
-        }
-
-        output = ec::pid(info, lastInput, setpt, &name);
-    }
+    info->lastOutput = output;
 
     // Output new value
     outputProc(output);
diff --git a/pid/pidcontroller.hpp b/pid/pidcontroller.hpp
index 05cbd71..91147d9 100644
--- a/pid/pidcontroller.hpp
+++ b/pid/pidcontroller.hpp
@@ -24,6 +24,7 @@
         Controller(), _owner(owner), _id(id)
     {
         _pid_info.initialized = false;
+        _pid_info.checkHysterWithSetpt = false;
         _pid_info.ts = static_cast<double>(0.0);
         _pid_info.integral = static_cast<double>(0.0);
         _pid_info.lastOutput = static_cast<double>(0.0);
@@ -73,6 +74,8 @@
         return lastInput;
     }
 
+    double calPIDOutput(double setpt, double input, ec::pid_info_t* info);
+
   protected:
     ZoneInterface* _owner;
     std::string _id;
diff --git a/pid/util.cpp b/pid/util.cpp
index ac6edb1..dbad60e 100644
--- a/pid/util.cpp
+++ b/pid/util.cpp
@@ -26,6 +26,7 @@
 
 void initializePIDStruct(ec::pid_info_t* info, const ec::pidinfo& initial)
 {
+    info->checkHysterWithSetpt = initial.checkHysterWithSetpt;
     info->ts = initial.ts;
     info->proportionalCoeff = initial.proportionalCoeff;
     info->integralCoeff = initial.integralCoeff;
diff --git a/pid/zone.cpp b/pid/zone.cpp
index e5eddca..5332efe 100644
--- a/pid/zone.cpp
+++ b/pid/zone.cpp
@@ -120,15 +120,32 @@
         return;
     }
 
-    _SetPoints.push_back(setPoint);
+    auto profileName = name;
+    if (getAccSetPoint())
+    {
+        /*
+         * If the name of controller is Linear_Temp_CPU0.
+         * The profile name will be Temp_CPU0.
+         */
+        profileName = name.substr(name.find("_") + 1);
+        _SetPoints[profileName] += setPoint;
+    }
+    else
+    {
+        if (_SetPoints[profileName] < setPoint)
+        {
+            _SetPoints[profileName] = setPoint;
+        }
+    }
+
     /*
      * if there are multiple thermal controllers with the same
      * value, pick the first one in the iterator
      */
-    if (_maximumSetPoint < setPoint)
+    if (_maximumSetPoint < _SetPoints[profileName])
     {
-        _maximumSetPoint = setPoint;
-        _maximumSetPointName = name;
+        _maximumSetPoint = _SetPoints[profileName];
+        _maximumSetPointName = profileName;
     }
 }
 
@@ -208,7 +225,16 @@
 void DbusPidZone::addThermalInput(const std::string& therm,
                                   bool missingAcceptable)
 {
-    _thermalInputs.push_back(therm);
+    /*
+     * One sensor may have stepwise and PID at the same time.
+     * Searching the sensor name before inserting it to avoid duplicated sensor
+     * names.
+     */
+    if (std::find(_thermalInputs.begin(), _thermalInputs.end(), therm) ==
+        _thermalInputs.end())
+    {
+        _thermalInputs.push_back(therm);
+    }
 
     if (missingAcceptable)
     {
@@ -287,6 +313,33 @@
     }
 
     /*
+     * Combine the maximum SetPoint Name if the controllers have same profile
+     * name. e.g., PID_BB_INLET_TEMP_C + Stepwise_BB_INLET_TEMP_C.
+     */
+    if (getAccSetPoint())
+    {
+        auto profileName = _maximumSetPointName;
+        _maximumSetPointName = "";
+
+        for (auto& p : _thermals)
+        {
+            auto controllerID = p->getID();
+            auto found = controllerID.find(profileName);
+            if (found != std::string::npos)
+            {
+                if (_maximumSetPointName.empty())
+                {
+                    _maximumSetPointName = controllerID;
+                }
+                else
+                {
+                    _maximumSetPointName += " + " + controllerID;
+                }
+            }
+        }
+    }
+
+    /*
      * If the maximum RPM setpoint output is below the minimum RPM
      * setpoint, set it to the minimum.
      */
@@ -579,4 +632,9 @@
     }
 }
 
+bool DbusPidZone::getAccSetPoint(void) const
+{
+    return _accumulateSetPoint;
+}
+
 } // namespace pid_control
diff --git a/pid/zone.hpp b/pid/zone.hpp
index 464e672..52180a5 100644
--- a/pid/zone.hpp
+++ b/pid/zone.hpp
@@ -49,11 +49,13 @@
   public:
     DbusPidZone(int64_t zone, double minThermalOutput, double failSafePercent,
                 conf::CycleTime cycleTime, const SensorManager& mgr,
-                sdbusplus::bus_t& bus, const char* objPath, bool defer) :
+                sdbusplus::bus_t& bus, const char* objPath, bool defer,
+                bool accumulateSetPoint) :
         ModeObject(bus, objPath,
                    defer ? ModeObject::action::defer_emit
                          : ModeObject::action::emit_object_added),
         _zoneId(zone), _maximumSetPoint(),
+        _accumulateSetPoint(accumulateSetPoint),
         _minThermalOutputSetPt(minThermalOutput),
         _zoneFailSafePercent(failSafePercent), _cycleTime(cycleTime), _mgr(mgr)
     {
@@ -72,6 +74,7 @@
     void setManualMode(bool mode);
     bool getFailSafeMode(void) const override;
     void markSensorMissing(const std::string& name);
+    bool getAccSetPoint(void) const override;
 
     int64_t getZoneID(void) const override;
     void addSetPoint(double setPoint, const std::string& name) override;
@@ -209,6 +212,7 @@
     std::string _maximumSetPointNamePrev;
     bool _manualMode = false;
     bool _redundantWrite = false;
+    bool _accumulateSetPoint = false;
     const double _minThermalOutputSetPt;
     // Current fail safe Percent.
     double _failSafePercent;
@@ -219,7 +223,7 @@
     std::set<std::string> _failSafeSensors;
     std::set<std::string> _missingAcceptable;
 
-    std::vector<double> _SetPoints;
+    std::map<std::string, double> _SetPoints;
     std::vector<double> _RPMCeilings;
     std::vector<std::string> _fanInputs;
     std::vector<std::string> _thermalInputs;
diff --git a/pid/zone_interface.hpp b/pid/zone_interface.hpp
index 7797740..31f3256 100644
--- a/pid/zone_interface.hpp
+++ b/pid/zone_interface.hpp
@@ -104,6 +104,11 @@
      */
     virtual bool getRedundantWrite(void) const = 0;
 
+    /** Returns true if user wants to accumulate the output PWM of different
+     * controllers with same sensor
+     */
+    virtual bool getAccSetPoint(void) const = 0;
+
     /** For each fan pid, do processing. */
     virtual void processFans(void) = 0;
     /** For each thermal pid, do processing. */