WIP using new PositionWatcher

lib/position_watcher/PositionWatcher.cpp

@@ -0,0 +1,53 @@
+#include "PositionWatcher.h"
+#include <Arduino.h>
+
+void PositionWatcher::start(int8_t newTargetValue)
+{
+    targetValue = newTargetValue;
+    lastPollTime = 0;
+    pollingInterval = 2000;
+    maxAttempts = 3;
+    maxConsecutiveDuplicates = 2;
+    consecutiveDuplicates = 0;
+    currentAttempt = 0;
+    isActive = true;
+}
+
+bool PositionWatcher::shouldFetch()
+{
+    if (isWatching() && millis() - lastPollTime > pollingInterval) {
+        if (currentAttempt >= maxAttempts) {
+            isActive = false;
+            return false;
+        }
+        return true;
+    }
+    return false;
+}
+
+bool PositionWatcher::isWatching()
+{
+    return isActive;
+}
+
+void PositionWatcher::fetchQueued()
+{
+    lastPollTime = millis();
+    currentAttempt++;
+}
+
+void PositionWatcher::fetchReceived(int8_t value)
+{
+    currentAttempt = 0;
+    if (value == targetValue) {
+        isActive = false;
+    } else if (lastValue == value) {
+        consecutiveDuplicates++;
+        if (consecutiveDuplicates >= maxConsecutiveDuplicates) {
+            isActive = false;
+        }
+    } else {
+        consecutiveDuplicates = 1;
+    }
+    lastValue = value;
+}

lib/position_watcher/PositionWatcher.h

@@ -0,0 +1,31 @@
+#ifndef POSITION_WATCHER_H
+#define POSITION_WATCHER_H
+
+#include <stdint.h>
+
+class PositionWatcher
+{
+private:
+    bool isActive;
+
+    int8_t targetValue;
+    int8_t lastValue;
+    int8_t consecutiveDuplicates;
+
+    uint32_t pollingInterval;
+
+    int8_t maxAttempts;
+    int8_t maxConsecutiveDuplicates;
+
+    int8_t currentAttempt;
+    uint32_t lastPollTime;
+
+public:
+    void start(int8_t newTargetValue);
+    bool shouldFetch();
+    bool isWatching();
+    void fetchQueued();
+    void fetchReceived(int8_t value);
+};
+
+#endif // POSITION_WATCHER_H