diff --git a/control/functor.hpp b/control/functor.hpp
index 46da0b3..6251ce8 100644
--- a/control/functor.hpp
+++ b/control/functor.hpp
@@ -109,8 +109,6 @@
         if (msg)
         {
             std::string intf;
-            std::map<std::string, sdbusplus::message::variant<T>> props;
-
             msg.read(intf);
             if (intf != _intf)
             {
@@ -118,6 +116,7 @@
                 return;
             }
 
+            std::map<std::string, PropertyVariantType> props;
             msg.read(props);
             auto it = props.find(_prop);
             if (it == props.cend())
@@ -126,8 +125,11 @@
                 return;
             }
 
-            _handler(zone, _path, _intf, _prop, std::forward<T>(
-                sdbusplus::message::variant_ns::get<T>(it->second)));
+            // Retrieve the property's value applying any visitors necessary
+            auto value =
+                zone.getPropertyValueVisitor<T>(_intf, _prop, it->second);
+
+            _handler(zone, _path, _intf, _prop, std::forward<T>(value));
         }
         else
         {
@@ -261,9 +263,6 @@
     {
         if (msg)
         {
-            std::map<std::string,
-                     std::map<std::string,
-                              sdbusplus::message::variant<T>>> intfProp;
             sdbusplus::message::object_path op;
 
             msg.read(op);
@@ -273,6 +272,8 @@
                 return;
             }
 
+            std::map<std::string, std::map<std::string,
+                    PropertyVariantType>> intfProp;
             msg.read(intfProp);
             auto itIntf = intfProp.find(_intf);
             if (itIntf == intfProp.cend())
@@ -287,8 +288,11 @@
                 return;
             }
 
-            _handler(zone, _path, _intf, _prop, std::forward<T>(
-                sdbusplus::message::variant_ns::get<T>(itProp->second)));
+            // Retrieve the property's value applying any visitors necessary
+            auto value =
+                zone.getPropertyValueVisitor<T>(_intf, _prop, itProp->second);
+
+            _handler(zone, _path, _intf, _prop, std::forward<T>(value));
         }
     }
 
diff --git a/control/types.hpp b/control/types.hpp
index 9b65c5f..04621e2 100644
--- a/control/types.hpp
+++ b/control/types.hpp
@@ -34,6 +34,7 @@
 using PropertyVariantType = sdbusplus::message::variant<bool,
                                                         int32_t,
                                                         int64_t,
+                                                        double,
                                                         std::string>;
 
 constexpr auto fanNamePos = 0;
diff --git a/control/zone.hpp b/control/zone.hpp
index 6982508..36fdb54 100644
--- a/control/zone.hpp
+++ b/control/zone.hpp
@@ -221,6 +221,64 @@
         };
 
         /**
+         * @brief Get a property's value after applying a set of visitors
+         * to translate the property value's type change to keep from
+         * affecting the configured use of the property.
+         *
+         * @param[in] intf = Interface name containing the property
+         * @param[in] prop = Property name
+         * @param[in] variant = Variant containing the property's value from
+         *                      the supported property types.
+         */
+        template <typename T>
+        inline auto getPropertyValueVisitor(
+            const char* intf,
+            const char* prop,
+            PropertyVariantType& variant)
+        {
+            T value;
+
+            // Handle the transition of the dbus sensor value type from
+            // int64 to double which also removed the scale property.
+            // https://gerrit.openbmc-project.xyz/11739
+            if (strcmp(intf, "xyz.openbmc_project.Sensor.Value") == 0 &&
+                strcmp(prop, "Value") == 0)
+            {
+                std::visit([&value](auto&& val)
+                {
+                    // If the type configured is int64, but the sensor value
+                    // property's type is double, scale it by 1000 and return
+                    // the value as an int64 as configured.
+                    using V = std::decay_t<decltype(val)>;
+                    if constexpr(std::is_same_v<T, int64_t> &&
+                                 std::is_same_v<V, double>)
+                    {
+                        val = val * 1000;
+                        value = static_cast<T>(val);
+                    }
+                    // If the type configured matches the sensor value
+                    // property's type, just return the value as its
+                    // given type.
+                    else if constexpr((std::is_same_v<T, int64_t> &&
+                                       std::is_same_v<V, int64_t>) ||
+                                      (std::is_same_v<T, double> &&
+                                       std::is_same_v<V, double>))
+                    {
+                        value = val;
+                    }
+                }, variant);
+
+                return value;
+            }
+
+            // Default to return the property's value by the data type
+            // configured, applying no visitors to the variant.
+            value = std::get<T>(variant);
+
+            return value;
+        };
+
+        /**
          * @brief Remove an object's interface
          *
          * @param[in] object - Name of the object with the interface
@@ -598,12 +656,13 @@
                 }
             }
 
+            // Retrieve the property's value applying any visitors necessary
             auto service = getService(path, intf);
-            value = util::SDBusPlus::getProperty<T>(_bus,
-                                                    service,
-                                                    path,
-                                                    intf,
-                                                    prop);
+            auto variant =
+                util::SDBusPlus::getPropertyVariant<PropertyVariantType>(
+                    _bus, service, path, intf, prop);
+            value = getPropertyValueVisitor<T>(
+                intf.c_str(), prop.c_str(), variant);
 
             return value;
         };