diff --git a/monitor/fan.cpp b/monitor/fan.cpp
index 8a30300..52b4031 100644
--- a/monitor/fan.cpp
+++ b/monitor/fan.cpp
@@ -61,8 +61,11 @@
             rules::argNpath(0, util::INVENTORY_PATH + _name),
         std::bind(std::mem_fn(&Fan::presenceIfaceAdded), this,
                   std::placeholders::_1)),
-    _fanMissingErrorDelay(std::get<fanMissingErrDelayField>(def))
+    _fanMissingErrorDelay(std::get<fanMissingErrDelayField>(def)),
+    _countInterval(std::get<countIntervalField>(def))
 {
+    bool enableCountTimer = false;
+
     // Start from a known state of functional (even if
     // _numSensorFailsForNonFunc is 0)
     updateInventory(true);
@@ -80,6 +83,23 @@
             std::get<nonfuncRotorErrDelayField>(def), event));
 
         _trustManager->registerSensor(_sensors.back());
+        if (_sensors.back()->getMethod() == MethodMode::count)
+        {
+            enableCountTimer = true;
+        }
+    }
+
+    // If the error checking method will be 'count', then it needs a timer.
+    // The timer is repeating but is disabled immediately because it doesn't
+    // need to start yet.
+    if (enableCountTimer)
+    {
+        _countTimer = std::make_unique<
+            sdeventplus::utility::Timer<sdeventplus::ClockId::Monotonic>>(
+            event, std::bind(&Fan::countTimerExpired, this),
+            std::chrono::seconds(_countInterval));
+
+        _countTimer->setEnabled(false);
     }
 
 #ifndef MONITOR_USE_JSON
@@ -170,6 +190,12 @@
 {
     _monitorReady = true;
 
+    if (_countTimer)
+    {
+        _countTimer->resetRemaining();
+        _countTimer->setEnabled(true);
+    }
+
     std::for_each(_sensors.begin(), _sensors.end(), [this](auto& sensor) {
         if (_present)
         {
@@ -234,7 +260,28 @@
         }
     }
 
-    process(sensor);
+    // If using the timebased method to determine functional status,
+    // check now, otherwise let _countTimer handle it.  A timer is
+    // used for the count method so that stuck sensors will continue
+    // to be checked.
+    if (sensor.getMethod() == MethodMode::timebased)
+    {
+        process(sensor);
+    }
+}
+
+void Fan::countTimerExpired()
+{
+    // For sensors that use the 'count' method, time to check their
+    // status and increment/decrement counts as necessary.
+    for (auto& sensor : _sensors)
+    {
+        if (_trustManager->active() && !_trustManager->checkTrust(*sensor))
+        {
+            continue;
+        }
+        process(*sensor);
+    }
 }
 
 void Fan::process(TachSensor& sensor)
@@ -455,6 +502,12 @@
                             sensor->setFunctional(true);
                             _system.fanStatusChange(*this, true);
                         }
+
+                        // Set the counters back to zero
+                        if (sensor->getMethod() == MethodMode::count)
+                        {
+                            sensor->resetMethod();
+                        }
                     }
                     catch (const util::DBusServiceError& e)
                     {
@@ -509,6 +562,11 @@
                 sensor->stopTimer();
             }
         });
+
+        if (_countTimer)
+        {
+            _countTimer->setEnabled(false);
+        }
     }
 #endif
 }