diff --git a/pid/builder.cpp b/pid/builder.cpp
index d133662..8a6bd39 100644
--- a/pid/builder.cpp
+++ b/pid/builder.cpp
@@ -102,7 +102,8 @@
                 auto pid = FanController::createFanPid(
                     zone.get(), name, splitNames(inputs), info.pidInfo);
                 zone->addFanPID(std::move(pid));
-                zone->addPidFailSafePercent(name, info.failSafePercent);
+                zone->addPidFailSafePercent(splitNames(inputs),
+                                            info.failSafePercent);
             }
             else if (isThermalType(info.type))
             {
@@ -120,7 +121,8 @@
                 zone->addPidControlProcess(
                     name, info.type, info.setpoint, modeControlBus,
                     getPidControlPath(zoneId, name), deferSignals);
-                zone->addPidFailSafePercent(name, info.failSafePercent);
+                zone->addPidFailSafePercent(splitNames(inputs),
+                                            info.failSafePercent);
             }
             else if (info.type == "stepwise")
             {
@@ -135,7 +137,8 @@
                 zone->addPidControlProcess(
                     name, info.type, info.setpoint, modeControlBus,
                     getPidControlPath(zoneId, name), deferSignals);
-                zone->addPidFailSafePercent(name, info.failSafePercent);
+                zone->addPidFailSafePercent(splitNames(inputs),
+                                            info.failSafePercent);
             }
 
             std::cerr << "inputs: ";
diff --git a/pid/zone.cpp b/pid/zone.cpp
index 39ddc6d..901905d 100644
--- a/pid/zone.cpp
+++ b/pid/zone.cpp
@@ -104,7 +104,19 @@
         return;
     }
 
-    _failSafeSensors.emplace(name);
+    if (_sensorFailSafePercent[name] == 0)
+    {
+        _failSafeSensors[name] = _zoneFailSafePercent;
+    }
+    else
+    {
+        _failSafeSensors[name] = _sensorFailSafePercent[name];
+    }
+
+    if (debugEnabled)
+    {
+        std::cerr << "Sensor " << name << " marked missing\n";
+    }
 }
 
 int64_t DbusPidZone::getZoneID(void) const
@@ -166,9 +178,27 @@
     _maximumSetPointName.clear();
 }
 
-double DbusPidZone::getFailSafePercent(void) const
+double DbusPidZone::getFailSafePercent(void)
 {
-    return _failSafePercent;
+    std::map<std::string, double>::iterator maxData = std::max_element(
+        _failSafeSensors.begin(), _failSafeSensors.end(),
+        [](const std::pair<std::string, double> firstData,
+           const std::pair<std::string, double> secondData) {
+            return firstData.second < secondData.second;
+        });
+
+    // In dbus/dbusconfiguration.cpp, the default sensor failsafepercent is 0 if
+    // there is no setting in json.
+    // Therfore, if the max failsafe duty in _failSafeSensors is 0, set final
+    // failsafe duty to _zoneFailSafePercent.
+    if ((*maxData).second == 0)
+    {
+        return _zoneFailSafePercent;
+    }
+    else
+    {
+        return (*maxData).second;
+    }
 }
 
 double DbusPidZone::getMinThermalSetPoint(void) const
@@ -355,9 +385,9 @@
                   << _maximumSetPointName;
         for (const auto& sensor : _failSafeSensors)
         {
-            if (sensor.find("Fan") == std::string::npos)
+            if (sensor.first.find("Fan") == std::string::npos)
             {
-                std::cerr << " " << sensor;
+                std::cerr << " " << sensor.first;
             }
         }
         std::cerr << "\n";
@@ -482,8 +512,6 @@
         // Start all sensors in fail-safe mode.
         markSensorMissing(t);
     }
-    // Initialize Pid FailSafePercent
-    initPidFailSafePercent();
 }
 
 void DbusPidZone::dumpCache(void)
@@ -582,34 +610,33 @@
     return _pidsControlProcess[name]->enabled();
 }
 
-void DbusPidZone::initPidFailSafePercent(void)
+void DbusPidZone::addPidFailSafePercent(std::vector<std::string> inputs,
+                                        double percent)
 {
-    // Currently, find the max failsafe percent pwm settings from zone and
-    // controller, and assign it to zone failsafe percent.
-
-    _failSafePercent = _zoneFailSafePercent;
-    std::cerr << "zone: Zone" << _zoneId
-              << " zoneFailSafePercent: " << _zoneFailSafePercent << "\n";
-
-    for (const auto& [name, value] : _pidsFailSafePercent)
+    for (const auto& sensorName : inputs)
     {
-        _failSafePercent = std::max(_failSafePercent, value);
-        std::cerr << "pid: " << name << " failSafePercent: " << value << "\n";
+        if (_sensorFailSafePercent.find(sensorName) !=
+            _sensorFailSafePercent.end())
+        {
+            _sensorFailSafePercent[sensorName] =
+                std::max(_sensorFailSafePercent[sensorName], percent);
+            if (debugEnabled)
+            {
+                std::cerr << "Sensor " << sensorName
+                          << " failsafe percent updated to "
+                          << _sensorFailSafePercent[sensorName] << "\n";
+            }
+        }
+        else
+        {
+            _sensorFailSafePercent[sensorName] = percent;
+            if (debugEnabled)
+            {
+                std::cerr << "Sensor " << sensorName
+                          << " failsafe percent set to " << percent << "\n";
+            }
+        }
     }
-
-    // when the final failsafe percent is zero , it indicate no failsafe
-    // percent is configured  , set it to 100% as the default setting.
-    if (_failSafePercent == 0)
-    {
-        _failSafePercent = 100;
-    }
-    std::cerr << "Final zone" << _zoneId
-              << " failSafePercent: " << _failSafePercent << "\n";
-}
-
-void DbusPidZone::addPidFailSafePercent(std::string name, double percent)
-{
-    _pidsFailSafePercent[name] = percent;
 }
 
 std::string DbusPidZone::leader() const
diff --git a/pid/zone.hpp b/pid/zone.hpp
index 52180a5..8c49f1f 100644
--- a/pid/zone.hpp
+++ b/pid/zone.hpp
@@ -82,7 +82,7 @@
     void addRPMCeiling(double ceiling) override;
     void clearSetPoints(void) override;
     void clearRPMCeilings(void) override;
-    double getFailSafePercent(void) const override;
+    double getFailSafePercent(void) override;
     double getMinThermalSetPoint(void) const;
     uint64_t getCycleIntervalTime(void) const override;
     uint64_t getUpdateThermalsCycle(void) const override;
@@ -121,8 +121,7 @@
                               std::string objPath, bool defer);
     bool isPidProcessEnabled(std::string name);
 
-    void initPidFailSafePercent(void);
-    void addPidFailSafePercent(std::string name, double percent);
+    void addPidFailSafePercent(std::vector<std::string> inputs, double percent);
 
     void updateThermalPowerDebugInterface(std::string pidName,
                                           std::string leader, double input,
@@ -214,13 +213,11 @@
     bool _redundantWrite = false;
     bool _accumulateSetPoint = false;
     const double _minThermalOutputSetPt;
-    // Current fail safe Percent.
-    double _failSafePercent;
     // Zone fail safe Percent setting by configuration.
     const double _zoneFailSafePercent;
     const conf::CycleTime _cycleTime;
 
-    std::set<std::string> _failSafeSensors;
+    std::map<std::string, double> _failSafeSensors;
     std::set<std::string> _missingAcceptable;
 
     std::map<std::string, double> _SetPoints;
@@ -236,10 +233,10 @@
 
     std::map<std::string, std::unique_ptr<ProcessObject>> _pidsControlProcess;
     /*
-     * <key = pidname, value = pid failsafe percent>
-     * Pid fail safe Percent setting by each pid controller configuration.
+     * <key = sensor name, value = sensor failsafe percent>
+     * sensor fail safe Percent setting by each pid controller configuration.
      */
-    std::map<std::string, double> _pidsFailSafePercent;
+    std::map<std::string, double> _sensorFailSafePercent;
 };
 
 } // namespace pid_control
diff --git a/pid/zone_interface.hpp b/pid/zone_interface.hpp
index 52639f8..34a5352 100644
--- a/pid/zone_interface.hpp
+++ b/pid/zone_interface.hpp
@@ -88,7 +88,7 @@
     /** Return the rpm or pwm percent value to drive fan pids when zone is in
      * fail safe.
      */
-    virtual double getFailSafePercent() const = 0;
+    virtual double getFailSafePercent() = 0;
 
     /** Return the zone's cycle time settings */
     virtual uint64_t getCycleIntervalTime(void) const = 0;