ADD speedometer and gear class

common/speedometer.cpp

@@ -0,0 +1,125 @@
+// Copyright 2022 Haute école d'ingénierie et d'architecture de Fribourg
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/****************************************************************************
+ * @file speedometer_device.cpp
+ * @author Serge Ayer <serge.ayer@hefr.ch>
+ *
+ * @brief WheelCounterDevice implementation (static scheduling)
+ *
+ * @date 2023-08-20
+ * @version 1.0.0
+ ***************************************************************************/
+
+#include "speedometer.hpp"
+
+#include <chrono>
+#include <ratio>
+
+// from disco_h747i/wrappers
+#include "joystick.hpp"
+#include "mbed_trace.h"
+
+#if MBED_CONF_MBED_TRACE_ENABLE
+#define TRACE_GROUP "Speedometer"
+#endif  // MBED_CONF_MBED_TRACE_ENABLE
+
+namespace bike_computer {
+
+Speedometer::Speedometer(Timer& timer) : _timer(timer) {
+    // update _lastTime
+    _lastTime = _timer.elapsed_time();
+}
+
+void Speedometer::setCurrentRotationTime(
+    const std::chrono::milliseconds& currentRotationTime) {
+    if (_pedalRotationTime != currentRotationTime) {
+        // compute distance before changing the rotation time
+        computeDistance();
+
+        // change pedal rotation time
+        _pedalRotationTime = currentRotationTime;
+
+        // compute speed with the new pedal rotation time
+        computeSpeed();
+    }
+}
+
+void Speedometer::setGearSize(uint8_t gearSize) {
+    if (_gearSize != gearSize) {
+        // compute distance before chaning the gear size
+        computeDistance();
+
+        // change gear size
+        _gearSize = gearSize;
+
+        // compute speed with the new gear size
+        computeSpeed();
+    }
+}
+
+float Speedometer::getCurrentSpeed() const { return _currentSpeed; }
+
+float Speedometer::getDistance() {
+    // make sure to update the distance traveled
+    computeDistance();
+    return _totalDistance;
+}
+
+void Speedometer::reset() {
+    // TODO : done
+    this->_totalDistanceMutex.lock();
+    this->_totalDistance = 0.0f;
+    this->_totalDistanceMutex.unlock();
+}
+
+#if defined(MBED_TEST_MODE)
+uint8_t Speedometer::getGearSize() const { return _gearSize; }
+
+float Speedometer::getWheelCircumference() const { return kWheelCircumference; }
+
+float Speedometer::getTraySize() const { return kTraySize; }
+
+std::chrono::milliseconds Speedometer::getCurrentPedalRotationTime() const {
+    return _pedalRotationTime;
+}
+
+#endif  // defined(MBED_TEST_MODE)
+
+void Speedometer::computeSpeed() {
+    // For computing the speed given a rear gear (braquet), one must divide the size of
+    // the tray (plateau) by the size of the rear gear (pignon arrière), and then multiply
+    // the result by the circumference of the wheel. Example: tray = 50, rear gear = 15.
+    // Distance run with one pedal turn (wheel circumference = 2.10 m) = 50/15 * 2.1 m
+    // = 6.99m If you ride at 80 pedal turns / min, you run a distance of 6.99 * 80 / min
+    // ~= 560 m / min = 33.6 km/h
+
+    // TODO
+    
+
+}
+
+void Speedometer::computeDistance() {
+    // For computing the speed given a rear gear (braquet), one must divide the size of
+    // the tray (plateau) by the size of the rear gear (pignon arrière), and then multiply
+    // the result by the circumference of the wheel. Example: tray = 50, rear gear = 15.
+    // Distance run with one pedal turn (wheel circumference = 2.10 m) = 50/15 * 2.1 m
+    // = 6.99m If you ride at 80 pedal turns / min, you run a distance of 6.99 * 80 / min
+    // ~= 560 m / min = 33.6 km/h. We then multiply the speed by the time for getting the
+    // distance traveled.
+
+    // TODO
+}
+
+}  // namespace bike_computer

common/speedometer.hpp

@@ -0,0 +1,91 @@
+// Copyright 2022 Haute école d'ingénierie et d'architecture de Fribourg
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/****************************************************************************
+ * @file speedometer_device.hpp
+ * @author Serge Ayer <serge.ayer@hefr.ch>
+ *
+ * @brief WheelCounterDevice header file (static scheduling)
+ *
+ * @date 2023-08-20
+ * @version 1.0.0
+ ***************************************************************************/
+
+#pragma once
+
+#include "constants.hpp"
+#include "mbed.h"
+
+namespace bike_computer {
+
+class Speedometer {
+   public:
+    explicit Speedometer(Timer& timer);  // NOLINT(runtime/references)
+
+    // method used for setting the current pedal rotation time
+    void setCurrentRotationTime(const std::chrono::milliseconds& currentRotationTime);
+
+    // method used for setting/getting the current gear
+    void setGearSize(uint8_t gearSize);
+
+    // method called for getting the current speed (expressed in km / h)
+    float getCurrentSpeed() const;
+
+    // method called for getting the current traveled distance (expressed in km)
+    float getDistance();
+
+    // method called for resetting the traveled distance
+    void reset();
+
+    // methods used for tests only
+#if defined(MBED_TEST_MODE)
+    uint8_t getGearSize() const;
+    float getWheelCircumference() const;
+    float getTraySize() const;
+    std::chrono::milliseconds getCurrentPedalRotationTime() const;
+    void setOnResetCallback(mbed::Callback<void()> cb);
+#endif  // defined(MBED_TEST_MODE)
+
+   private:
+    // private methods
+    void computeSpeed();
+    void computeDistance();
+
+    // definition of task period time
+    static constexpr std::chrono::milliseconds kTaskPeriod = 400ms;
+    // definition of task execution time
+    static constexpr std::chrono::microseconds kTaskRunTime = 200000us;
+
+    // constants related to speed computation
+    static constexpr float kWheelCircumference   = 2.1f;
+    static constexpr uint8_t kTraySize           = 50;
+    std::chrono::microseconds _lastTime          = std::chrono::microseconds::zero();
+    std::chrono::milliseconds _pedalRotationTime = kInitialPedalRotationTime;
+
+    // data members
+    Timer& _timer;
+    LowPowerTicker _ticker;
+    float _currentSpeed = 0.0f;
+    Mutex _totalDistanceMutex;
+    float _totalDistance = 0.0f;
+    uint8_t _gearSize    = 1;
+
+    Thread _thread;
+
+#if defined(MBED_TEST_MODE)
+    mbed::Callback<void()> _cb;
+#endif
+};
+
+}  // namespace bike_computer