Implement lap tracking

Author: Louis Pearson

src/components/stopwatch/StopWatchController.cpp

@@ -4,27 +4,80 @@
 
 using namespace Pinetime::Controllers;
 
-// StopWatch::StopWatch() {}
+namespace {
+  TickType_t calculateDelta(const TickType_t startTime, const TickType_t currentTime) {
+    TickType_t delta = 0;
+    // Take care of overflow
+    if (startTime > currentTime) {
+      delta = 0xffffffff - startTime;
+      delta += (currentTime + 1);
+    } else {
+      delta = currentTime - startTime;
+    }
+    return delta;
+  }
+}
+
+StopWatch::StopWatch() {
+  clear();
+}
 
-// StopWatch::init() {}
+// State Change
 
-void StopWatch::start(uint32_t start) {
+void StopWatch::start(TickType_t start) {
   currentState = StopWatchStates::Running;
   startTime = start;
 }
 
-// void StopWatch::lap(uint32_t lapEnd);
-
-void StopWatch::pause(uint32_t end) {
+void StopWatch::pause(TickType_t end) {
   currentState = StopWatchStates::Paused;
-  timeElapsedPreviously += end - startTime;
+  timeElapsedPreviously += calculateDelta(startTime, end);
 }
 
 void StopWatch::clear() {
   currentState = StopWatchStates::Cleared;
   timeElapsedPreviously = 0;
+
+  for (int i = 0; i < LAP_CAPACITY; i++) {
+    laps[i].count = 0;
+    laps[i].time = 0;
+  }
+  lapCount = 0;
+  lapHead = 0;
+}
+
+// Lap
+
+void StopWatch::pushLap(TickType_t lapEnd) {
+  laps[lapHead].time = lapEnd;
+  laps[lapHead].count = lapCount + 1;
+  lapCount += 1;
+  lapHead = lapCount % LAP_CAPACITY;
 }
 
+uint32_t StopWatch::getLapNum() {
+  if (lapCount < LAP_CAPACITY)
+    return lapCount;
+  else
+    return LAP_CAPACITY;
+}
+
+uint32_t StopWatch::getLapCount() {
+  return lapCount;
+}
+
+LapInfo_t *StopWatch::lastLap(uint32_t lap) {
+  if (lap >= LAP_CAPACITY || lap >= lapCount || lapCount == 0) {
+    // Return "empty" LapInfo_t
+    return &emptyLapInfo;
+  }
+  // Index backwards
+  uint32_t index = ((lapHead + LAP_CAPACITY) - lap) % LAP_CAPACITY;
+  return &laps[index];
+}
+
+// Data acess
+
 uint32_t StopWatch::getStart() {
   return startTime;
 }

src/components/stopwatch/StopWatchController.h

@@ -1,9 +1,10 @@
 #pragma once
 
 #include <cstdint>
-// #include "portmacro_cmsis.h"
 #include "FreeRTOS.h"
 
+#define LAP_CAPACITY 2
+
 namespace Pinetime {
   namespace System {
     class SystemTask;
@@ -12,29 +13,55 @@ namespace Pinetime {
 
     enum class StopWatchStates { Cleared, Running, Paused };
 
+    struct LapInfo_t {
+      uint32_t count = 0; // Used to label the lap
+      TickType_t time = 0; // delta time from beginning of stopwatch
+    };
+
     class StopWatch {
     public:
-      StopWatch() = default;
+      StopWatch();
 
-      // void init();
-      void start(uint32_t start);
-      // void lap(uint32_t lapEnd);
-      void pause(uint32_t end);
+      // StopWatch functionality and data
+      void start(TickType_t start);
+      void pause(TickType_t end);
       void clear();
 
-      uint32_t getStart();
-      uint32_t getElapsedPreviously();
+      TickType_t getStart();
+      TickType_t getElapsedPreviously();
+
+      // Lap functionality
+
+      /// Only the latest laps are stored, the lap count is saved until reset
+      void pushLap(TickType_t lapEnd);
+
+      /// Returns actual count of stored laps
+      uint32_t getLapNum();
+
+      /// Returns lapCount
+      uint32_t getLapCount();
+
+      /// Indexes into lap history, with 0 being the latest lap.
+      /// If the lap is unavailable, count and time will be 0. If there is a
+      /// real value, count should be above 0
+      LapInfo_t *lastLap(uint32_t lap=0);
 
       bool isRunning();
       bool isCleared();
       bool isPaused();
 
     private:
-        StopWatchStates currentState = StopWatchStates::Cleared;
+      // Current state of stopwatch
+      StopWatchStates currentState = StopWatchStates::Cleared;
       // Start time of current duration
-        TickType_t startTime;
+      TickType_t startTime = 0;
       // How much time was elapsed before current duration
-        TickType_t timeElapsedPreviously = 0;
+      TickType_t timeElapsedPreviously = 0;
+      // Stores lap times
+      LapInfo_t laps[LAP_CAPACITY];
+      LapInfo_t emptyLapInfo = { .count = 0, .time = 0 };
+      uint32_t lapCount = 0;
+      uint32_t lapHead = 0;
     };
   }
 }

src/displayapp/screens/StopWatch.cpp

@@ -51,9 +51,7 @@ StopWatch::StopWatch(DisplayApp* app, System::SystemTask& systemTask, Controller
     dateTimeController {dateTimeController},
     stopWatchController {stopWatchController},
     timeElapsed {},
-    currentTimeSeparated {},
-    lapBuffer {},
-    lapNr {} {
+    currentTimeSeparated {} {
 
   // Running time
   time = lv_label_create(lv_scr_act(), nullptr);
@@ -121,6 +119,12 @@ StopWatch::StopWatch(DisplayApp* app, System::SystemTask& systemTask, Controller
     lv_label_set_text_fmt(msecTime, "%02d", currentTimeSeparated.hundredths);
     lv_obj_set_state(btnStopLap, LV_STATE_DEFAULT);
     lv_obj_set_state(txtStopLap, LV_STATE_DEFAULT);
+  } else {
+    reset();
+  }
+
+  if (stopWatchController.getLapCount() > 0) {
+    refreshLaps();
   }
 }
 
@@ -139,8 +143,7 @@ void StopWatch::reset() {
 
   lv_label_set_text(lapOneText, "");
   lv_label_set_text(lapTwoText, "");
-  lapBuffer.clearBuffer();
-  lapNr = 0;
+
   lv_obj_set_state(btnStopLap, LV_STATE_DISABLED);
   lv_obj_set_state(txtStopLap, LV_STATE_DISABLED);
 }
@@ -179,6 +182,35 @@ void StopWatch::Refresh() {
   }
 }
 
+void StopWatch::refreshLaps() {
+  Pinetime::Controllers::LapInfo_t
+    // Latest lap
+    *lap1 = stopWatchController.lastLap(),
+    // Second latest lap
+    *lap2 = stopWatchController.lastLap(1);
+
+  if (lap1->count != 0) {
+    TimeSeparated_t laptime = convertTicksToTimeSegments(lap1->time);
+    lv_label_set_text_fmt(
+      lapOneText,
+      "#%2d   %2d:%02d.%02d",
+      lap1->count,
+      laptime.mins,
+      laptime.secs,
+      laptime.hundredths);
+  }
+  if (lap2->count != 0) {
+    TimeSeparated_t laptime = convertTicksToTimeSegments(lap2->time);
+    lv_label_set_text_fmt(
+      lapTwoText,
+      "#%2d   %2d:%02d.%02d",
+      lap2->count,
+      laptime.mins,
+      laptime.secs,
+      laptime.hundredths);
+  }
+}
+
 void StopWatch::playPauseBtnEventHandler(lv_event_t event) {
   if (event != LV_EVENT_CLICKED) {
     return;
@@ -198,15 +230,19 @@ void StopWatch::stopLapBtnEventHandler(lv_event_t event) {
   }
   // If running, then this button is used to save laps
   if (stopWatchController.isRunning()) {
-    lapBuffer.addLaps(currentTimeSeparated);
-    lapNr++;
-    if (lapBuffer[1]) {
-      lv_label_set_text_fmt(
-        lapOneText, "#%2d   %2d:%02d.%02d", (lapNr - 1), lapBuffer[1]->mins, lapBuffer[1]->secs, lapBuffer[1]->hundredths);
-    }
-    if (lapBuffer[0]) {
-      lv_label_set_text_fmt(lapTwoText, "#%2d   %2d:%02d.%02d", lapNr, lapBuffer[0]->mins, lapBuffer[0]->secs, lapBuffer[0]->hundredths);
-    }
+    // lapBuffer.addLaps(currentTimeSeparated);
+    // lapNr++;
+    // if (lapBuffer[1]) {
+    //   lv_label_set_text_fmt(
+    //     lapOneText, "#%2d   %2d:%02d.%02d", (lapNr - 1), lapBuffer[1]->mins, lapBuffer[1]->secs, lapBuffer[1]->hundredths);
+    // }
+    // if (lapBuffer[0]) {
+    //   lv_label_set_text_fmt(lapTwoText, "#%2d   %2d:%02d.%02d", lapNr, lapBuffer[0]->mins, lapBuffer[0]->secs, lapBuffer[0]->hundredths);
+    // }
+    TickType_t currentTime = stopWatchController.getElapsedPreviously() + calculateDelta(stopWatchController.getStart(), xTaskGetTickCount());
+    stopWatchController.pushLap(currentTime);
+
+    refreshLaps();
   } else if (stopWatchController.isPaused()) {
     stopWatchController.clear();
     reset();

src/displayapp/screens/StopWatch.h

@@ -2,6 +2,7 @@
 
 #include "Screen.h"
 #include "components/datetime/DateTimeController.h"
+#include "components/stopwatch/StopWatchController.h"
 #include "../LittleVgl.h"
 
 #include "FreeRTOS.h"
@@ -12,54 +13,12 @@
 
 namespace Pinetime::Applications::Screens {
 
-  enum class States { Init, Running, Halted };
-
   struct TimeSeparated_t {
     int mins;
     int secs;
     int hundredths;
   };
 
-  // A simple buffer to hold the latest two laps
-  template <int N> struct LapTextBuffer_t {
-    LapTextBuffer_t() : buffer {}, currentSize {}, capacity {N}, head {-1} {
-    }
-
-    void addLaps(const TimeSeparated_t& timeVal) {
-      head++;
-      head %= capacity;
-      buffer[head] = timeVal;
-
-      if (currentSize < capacity) {
-        currentSize++;
-      }
-    }
-
-    void clearBuffer() {
-      buffer = {};
-      currentSize = 0;
-      head = -1;
-    }
-
-    TimeSeparated_t* operator[](std::size_t idx) {
-      // Sanity check for out-of-bounds
-      if (idx >= 0 && idx < capacity) {
-        if (idx < currentSize) {
-          // This transformation is to ensure that head is always pointing to index 0.
-          const auto transformed_idx = (head - idx) % capacity;
-          return (&buffer[transformed_idx]);
-        }
-      }
-      return nullptr;
-    }
-
-  private:
-    std::array<TimeSeparated_t, N> buffer;
-    uint8_t currentSize;
-    uint8_t capacity;
-    int8_t head;
-  };
-
   class StopWatch : public Screen {
   public:
     StopWatch(DisplayApp* app,
@@ -76,6 +35,7 @@ namespace Pinetime::Applications::Screens {
     void reset();
     void start();
     void pause();
+    void refreshLaps() ;
 
   private:
     Pinetime::System::SystemTask& systemTask;
@@ -84,8 +44,7 @@ namespace Pinetime::Applications::Screens {
 
     TickType_t timeElapsed;
     TimeSeparated_t currentTimeSeparated; // Holds Mins, Secs, millisecs
-    LapTextBuffer_t<2> lapBuffer;
-    int lapNr = 0;
+
     lv_obj_t *dateTime, *time, *msecTime, *btnPlayPause, *btnStopLap, *txtPlayPause, *txtStopLap;
     lv_obj_t *lapOneText, *lapTwoText;