diff --git a/powercap.cpp b/powercap.cpp
index 2555d95..cd11059 100644
--- a/powercap.cpp
+++ b/powercap.cpp
@@ -1,10 +1,11 @@
+#include "occ_status.hpp"
+
 #include <fmt/core.h>
 
 #include <phosphor-logging/log.hpp>
 #include <powercap.hpp>
 
 #include <cassert>
-#include <regex>
 
 namespace open_power
 {
@@ -18,10 +19,77 @@
 
 constexpr auto POWER_CAP_PROP = "PowerCap";
 constexpr auto POWER_CAP_ENABLE_PROP = "PowerCapEnable";
+constexpr auto POWER_CAP_SOFT_MIN = "MinSoftPowerCapValue";
+constexpr auto POWER_CAP_HARD_MIN = "MinPowerCapValue";
+constexpr auto POWER_CAP_MAX = "MaxPowerCapValue";
 
 using namespace phosphor::logging;
 namespace fs = std::filesystem;
 
+void PowerCap::updatePcapBounds()
+{
+    // Build the hwmon string to write the power cap bounds
+    fs::path minName = getPcapFilename(std::regex{"power\\d+_cap_min$"});
+    fs::path softMinName =
+        getPcapFilename(std::regex{"power\\d+_cap_min_soft$"});
+    fs::path maxName = getPcapFilename(std::regex{"power\\d+_cap_max$"});
+
+    // Read the power cap bounds from sysfs files
+    uint64_t cap;
+    uint32_t capSoftMin = 0, capHardMin = 0, capMax = INT_MAX;
+    std::ifstream softMinFile(softMinName, std::ios::in);
+    if (softMinFile)
+    {
+        softMinFile >> cap;
+        softMinFile.close();
+        // Convert to Watts
+        capSoftMin = cap / 1000000;
+    }
+    else
+    {
+        log<level::ERR>(
+            fmt::format(
+                "updatePcapBounds: unable to find pcap_min_soft file: {} (errno={})",
+                pcapBasePathname.c_str(), errno)
+                .c_str());
+    }
+    std::ifstream minFile(minName, std::ios::in);
+    if (minFile)
+    {
+        minFile >> cap;
+        minFile.close();
+        // Convert to Watts
+        capHardMin = cap / 1000000;
+    }
+    else
+    {
+        log<level::ERR>(
+            fmt::format(
+                "updatePcapBounds: unable to find cap_min file: {} (errno={})",
+                pcapBasePathname.c_str(), errno)
+                .c_str());
+    }
+    std::ifstream maxFile(maxName, std::ios::in);
+    if (maxFile)
+    {
+        maxFile >> cap;
+        maxFile.close();
+        // Convert to Watts
+        capMax = cap / 1000000;
+    }
+    else
+    {
+        log<level::ERR>(
+            fmt::format(
+                "updatePcapBounds: unable to find cap_max file: {} (errno={})",
+                pcapBasePathname.c_str(), errno)
+                .c_str());
+    }
+
+    // Save the bounds to dbus
+    updateDbusPcap(capSoftMin, capHardMin, capMax);
+}
+
 uint32_t PowerCap::getOccInput(uint32_t pcap, bool pcapEnabled)
 {
     if (!pcapEnabled)
@@ -74,56 +142,65 @@
     }
 }
 
-std::string PowerCap::getPcapFilename(const fs::path& path)
+fs::path PowerCap::getPcapFilename(const std::regex& expr)
 {
-    std::regex expr{"power\\d+_cap_user$"};
-    for (auto& file : fs::directory_iterator(path))
+    if (pcapBasePathname.empty())
+    {
+        static bool tracedError = false;
+        pcapBasePathname = occStatus.getHwmonPath();
+        if (!fs::exists(pcapBasePathname) && !tracedError)
+        {
+            log<level::ERR>(fmt::format("Power Cap base filename not found: {}",
+                                        pcapBasePathname.c_str())
+                                .c_str());
+            tracedError = true;
+        }
+    }
+    for (auto& file : fs::directory_iterator(pcapBasePathname))
     {
         if (std::regex_search(file.path().string(), expr))
         {
-            return file.path().filename();
+            return file;
         }
     }
-    return std::string{};
+    // return empty path
+    return fs::path{};
 }
 
 void PowerCap::writeOcc(uint32_t pcapValue)
 {
-    // Create path out to master occ hwmon entry
-    std::unique_ptr<fs::path> fileName =
-        std::make_unique<fs::path>(OCC_HWMON_PATH);
-    *fileName /= occMasterName;
-    *fileName /= "hwmon";
-
-    // Need to get the hwmonXX directory name, there better only be 1 dir
-    assert(std::distance(fs::directory_iterator(*fileName),
-                         fs::directory_iterator{}) == 1);
-    // Now set our path to this full path, including this hwmonXX directory
-    fileName = std::make_unique<fs::path>(*fs::directory_iterator(*fileName));
-    // Append on the hwmon string where we write the user power cap
-
-    auto baseName = getPcapFilename(*fileName);
-    if (baseName.empty())
+    // Build the hwmon string to write the user power cap
+    fs::path fileName = getPcapFilename(std::regex{"power\\d+_cap_user$"});
+    if (fileName.empty())
     {
         log<level::ERR>(
             fmt::format("Could not find a power cap file to write to: {})",
-                        fileName->c_str())
+                        pcapBasePathname.c_str())
                 .c_str());
         return;
     }
-    *fileName /= baseName;
 
     uint64_t microWatts = pcapValue * 1000000ull;
 
     auto pcapString{std::to_string(microWatts)};
 
-    log<level::INFO>("Writing pcap value to hwmon",
-                     entry("PCAP_PATH=%s", fileName->c_str()),
-                     entry("PCAP_VALUE=%s", pcapString.c_str()));
     // Open the hwmon file and write the power cap
-    std::ofstream file(*fileName, std::ios::out);
-    file << pcapString;
-    file.close();
+    std::ofstream file(fileName, std::ios::out);
+    if (file)
+    {
+        log<level::INFO>(fmt::format("Writing {}uW to {}", pcapString.c_str(),
+                                     fileName.c_str())
+                             .c_str());
+        file << pcapString;
+        file.close();
+    }
+    else
+    {
+        log<level::ERR>(fmt::format("Failed writing {}uW to {} (errno={})",
+                                    microWatts, fileName.c_str(), errno)
+                            .c_str());
+    }
+
     return;
 }
 
@@ -131,7 +208,7 @@
 {
     if (!occStatus.occActive())
     {
-        // Nothing to  do
+        // Nothing to do
         return;
     }
 
@@ -142,43 +219,102 @@
     std::map<std::string, std::variant<uint32_t, bool>> msgData;
     msg.read(msgSensor, msgData);
 
-    // Retrieve which property changed via the msg and read the other one
-    auto valPropMap = msgData.find(POWER_CAP_PROP);
-    if (valPropMap != msgData.end())
+    bool changeFound = false;
+    for (const auto& [prop, value] : msgData)
     {
-        pcap = std::get<uint32_t>(valPropMap->second);
-        pcapEnabled = getPcapEnabled();
-    }
-    else
-    {
-        valPropMap = msgData.find(POWER_CAP_ENABLE_PROP);
-        if (valPropMap != msgData.end())
+        if (prop == POWER_CAP_PROP)
         {
-            pcapEnabled = std::get<bool>(valPropMap->second);
+            pcap = std::get<uint32_t>(value);
+            pcapEnabled = getPcapEnabled();
+            changeFound = true;
+        }
+        else if (prop == POWER_CAP_ENABLE_PROP)
+        {
+            pcapEnabled = std::get<bool>(value);
             pcap = getPcap();
+            changeFound = true;
         }
         else
         {
-            log<level::INFO>("Unknown power cap property changed");
-            return;
+            // Ignore other properties
+            log<level::DEBUG>(
+                fmt::format(
+                    "pcapChanged: Unknown power cap property changed {} to {}",
+                    prop.c_str(), std::get<uint32_t>(value))
+                    .c_str());
         }
     }
 
-    log<level::INFO>(
-        fmt::format("Power Cap Property Change (cap={}W (input), enabled={})",
-                    pcap, pcapEnabled ? 'y' : 'n')
-            .c_str());
+    if (changeFound)
+    {
+        log<level::INFO>(
+            fmt::format(
+                "Power Cap Property Change (cap={}W (input), enabled={})", pcap,
+                pcapEnabled ? 'y' : 'n')
+                .c_str());
 
-    // Determine desired action to write to occ
+        // Determine desired action to write to occ
 
-    auto occInput = getOccInput(pcap, pcapEnabled);
+        auto occInput = getOccInput(pcap, pcapEnabled);
 
-    // Write action to occ
-    writeOcc(occInput);
+        // Write action to occ
+        writeOcc(occInput);
+    }
 
     return;
 }
 
+// Update the Power Cap bounds on DBus
+bool PowerCap::updateDbusPcap(uint32_t softMin, uint32_t hardMin, uint32_t max)
+{
+    bool complete = true;
+
+    try
+    {
+        utils::setProperty(PCAP_PATH, PCAP_INTERFACE, POWER_CAP_SOFT_MIN,
+                           softMin);
+    }
+    catch (const sdbusplus::exception::exception& e)
+    {
+        log<level::ERR>(
+            fmt::format(
+                "updateDbusPcap: Failed to set SOFT PCAP to {}W due to {}",
+                softMin, e.what())
+                .c_str());
+        complete = false;
+    }
+
+    try
+    {
+        utils::setProperty(PCAP_PATH, PCAP_INTERFACE, POWER_CAP_HARD_MIN,
+                           hardMin);
+    }
+    catch (const sdbusplus::exception::exception& e)
+    {
+        log<level::ERR>(
+            fmt::format(
+                "updateDbusPcap: Failed to set HARD PCAP to {}W due to {}",
+                hardMin, e.what())
+                .c_str());
+        complete = false;
+    }
+
+    try
+    {
+        utils::setProperty(PCAP_PATH, PCAP_INTERFACE, POWER_CAP_MAX, max);
+    }
+    catch (const sdbusplus::exception::exception& e)
+    {
+        log<level::ERR>(
+            fmt::format(
+                "updateDbusPcap: Failed to set MAX PCAP to {}W due to {}", max,
+                e.what())
+                .c_str());
+        complete = false;
+    }
+
+    return complete;
+}
 } // namespace powercap
 
 } // namespace occ