FWT-11 #2 hallelujah effect sensor

CMakeLists.txt

@@ -1,5 +1,5 @@
 ###############################################################################
-# Top level CMakeList for building the *EVT_BOARD_NAME* source code
+# Top level CMakeList for building the WSS source code
 ###############################################################################
 cmake_minimum_required(VERSION 3.15)
 
@@ -44,7 +44,7 @@ include(${EVT_CORE_DIR}/cmake/evt-core_install.cmake)
 ###############################################################################
 # Project Setup
 ###############################################################################
-set(BOARD_LIB_NAME BOARD_NAME)
+set(BOARD_LIB_NAME WSS)
 if("${BOARD_LIB_NAME}" STREQUAL BOARD_NAME)
     message(FATAL_ERROR
             "You must set the template project name in the top-level CMakeLists.txt")
@@ -55,22 +55,22 @@ file(STRINGS version.txt BOARD_VERSION)
 project(${BOARD_LIB_NAME}
         VERSION ${BOARD_VERSION}
         LANGUAGES CXX C
-        )
+)
 
 add_library(${PROJECT_NAME} STATIC)
 
 # Add sources
 target_sources(${PROJECT_NAME} PRIVATE
-        src/dev/LED.cpp
-        src/BOARD_NAME.cpp
-        )
+        src/WSS.cpp
+        src/dev/hallSensor.cpp
+)
 
 ###############################################################################
 # Handle dependencies
 ###############################################################################
 target_link_libraries(${PROJECT_NAME}
         PUBLIC EVT
-        )
+)
 
 ###############################################################################
 # Install and expose library
@@ -80,4 +80,4 @@ install_and_expose(${PROJECT_NAME})
 ###############################################################################
 # Build Target Code
 ###############################################################################
-add_subdirectory(targets)
+add_subdirectory(targets)

include/dev/hallSensor.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <EVT/io/GPIO.hpp>
+#include <EVT/DEV/RTCTimer.hpp>
+
+namespace IO = EVT::core::IO;
+namespace DEV = EVT::core::DEV;
+
+
+namespace hallSensor {
+
+class HallSensor {
+
+public:
+    enum WheelSpeedState {
+        STOPPED = 0,    // First pulse or wheel is dead
+        MAINTAIN = 1,   // Wheel is spinning at a constant speed or speeding up
+    };
+
+    // Constructor (take a GPIO instance and the radius of the wheel)
+    HallSensor(IO::GPIO& gpio, uint32_t wheelRadius);
+
+    uint32_t update(); // Update the wheel speed
+
+    // Get the current speed of the wheel
+    uint32_t getSpeed(uint32_t timeDiff);
+
+
+private:
+    IO::GPIO& gpio;            // GPIO instance for the sensor
+    uint32_t wheelRadius;  // Radius of the wheel
+    uint32_t prevTime;     // Previous time for calculating delta time
+    uint32_t wheelSpeed;   // Current speed of the wheel
+    WheelSpeedState state; // Current state of the wheel speed
+    bool isHigh;           // If the sensor is currently high
+};
+
+} // namespace hallSensor

src/dev/hallSensor.cpp

@@ -0,0 +1,67 @@
+#include "EVT/dev/RTC.hpp"
+#include "EVT/manager.hpp"
+#include <DEV/hallSensor.hpp>
+#include <EVT/io/GPIO.hpp>
+
+namespace IO = EVT::core::IO;
+namespace DEV = EVT::core::DEV;
+
+constexpr uint32_t THRESHOLD = 10; // Threshold for wheel speed
+constexpr uint32_t THETA = 2; // Constant for wheel speed calculation
+
+namespace hallSensor {
+    DEV::RTC& clock = DEV::getRTC();
+
+    HallSensor::HallSensor(IO::GPIO& gpio, uint32_t wheelRadius): gpio((IO::GPIO&) gpio), wheelRadius(wheelRadius) {
+        this->prevTime = 0;
+        this->wheelSpeed = 0;
+        this->state = WheelSpeedState::STOPPED;
+        this->isHigh = false;
+    }
+
+    uint32_t HallSensor::update(){
+        uint32_t timeDiff = 0;
+
+        switch (state) {
+            case WheelSpeedState::STOPPED:
+                if (isHigh) {
+                    // should never get here
+                    break;
+                }
+                else{
+                    prevTime = clock.getTime();
+                    isHigh = true;
+                    state = WheelSpeedState::MAINTAIN;
+                }
+            case WheelSpeedState::MAINTAIN:
+                if (gpio.readPin() == EVT::core::IO::GPIO::State::HIGH) {
+                    if(isHigh) {
+                        break;
+                    }
+                    else{
+                        timeDiff = clock.getTime() - prevTime;
+                        uint32_t possibleSpeed = getSpeed(timeDiff);
+                        if (possibleSpeed > THRESHOLD){
+                            state = WheelSpeedState::STOPPED;
+                            prevTime = 0;
+                            wheelSpeed = 0;
+                            isHigh = false;
+                        }
+                        else if (possibleSpeed < wheelSpeed){
+                            wheelSpeed = possibleSpeed;
+                        }
+                        else{
+                            //do nothing
+                        }
+                    }
+                }
+            return timeDiff;
+        }
+    }
+
+    uint32_t HallSensor::getSpeed(uint32_t timeDiff){
+        return (THETA * wheelRadius) / timeDiff;
+    }
+
+
+} // namespace hallSensor

targets/CMakeLists.txt

@@ -1,3 +1,3 @@
 # Add all targets
-add_subdirectory(blinkUtil)
-add_subdirectory(BIKE_NAME-BOARD_NAME)
+add_subdirectory(REV3-WSS)
+add_subdirectory(hallSensor)

targets/blinkUtil/CMakeLists.txt → targets/REV3-WSS/CMakeLists.txt

@@ -1,8 +1,7 @@
 include(${EVT_CORE_DIR}/cmake/evt-core_build.cmake)
 
-project(blinkUtil)
+project(REV3-WSS)
 cmake_minimum_required(VERSION 3.15)
 
 make_exe(${PROJECT_NAME} main.cpp)
 target_link_libraries(${PROJECT_NAME} PUBLIC ${BOARD_LIB_NAME})
-

targets/BIKE_NAME-BOARD_NAME/CMakeLists.txt → targets/hallSensor/CMakeLists.txt

@@ -1,6 +1,6 @@
 include(${EVT_CORE_DIR}/cmake/evt-core_build.cmake)
 
-project(BIKE_NAME-BOARD_NAME)
+project(hallSensor)
 cmake_minimum_required(VERSION 3.15)
 
 make_exe(${PROJECT_NAME} main.cpp)

targets/hallSensor/main.cpp

@@ -0,0 +1,35 @@
+/**
+* This is a basic sample of using the UART module. The program provides a
+* basic echo functionality where the uart will write back whatever the user
+* enters.
+*/
+
+#include <EVT/io/UART.hpp>
+#include <EVT/manager.hpp>
+#include <EVT/io/pin.hpp>
+#include <EVT/io/GPIO.hpp>
+#include <DEV/hallSensor.hpp>
+
+namespace IO = EVT::core::IO;
+
+int main() {
+   // Initialize system
+   EVT::core::platform::init();
+
+   // Setup UART
+   IO::UART& uart = IO::getUART<IO::Pin::UART_TX, IO::Pin::UART_RX>(9600);
+
+    // Setup GPIO
+    IO::GPIO& gpio = IO::getGPIO<IO::Pin::GPIO_0, IO::Pin::GPIO_1>();
+
+    // Setup Hall Sensor
+    constexpr uint32_t WHEEL_RADIUS = 10;
+    hallSensor::HallSensor hallSensor(gpio, WHEEL_RADIUS);
+
+    // Main loop
+    while (1) {
+        uint32_t timeDiff = hallSensor.update();
+        uart.printf("Wheel speed: %d\n", hallSensor.getSpeed(timeDiff));
+        uart.printf("Time Diff: %d\n", timeDiff);
+    }
+}