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/WSS.hpp

@@ -0,0 +1,86 @@
+#pragma once
+
+#include <EVT/io/CANDevice.hpp>
+#include <EVT/io/CANOpenMacros.hpp>
+#include <EVT/io/SPI.hpp>
+#include <co_core.h>
+#include <dev/HallSensor.hpp>
+
+#define NUM_HALLSENSORS 2
+
+using namespace EVT::core::IO;
+
+namespace WSS {
+
+/**
+ * This is an example of a class for a board
+ */
+class WSS : public CANDevice {
+public:
+    WSS(DEV::HallSensor& hallSensor1, DEV::HallSensor& hallSensor2);
+
+    static constexpr uint16_t NODE_ID = 8;
+
+    /**
+     * Gets the object dictionary
+     *
+     * @return an object dictionary
+     */
+    CO_OBJ_T* getObjectDictionary();
+
+    /**
+     * Updates the temperature values in an array and updates the error array from the TMU object.
+     */
+    void process();
+
+    /**
+     * Get the device's node ID
+     *
+     * @return The node ID of the can device.
+     */
+    uint8_t getNodeID() override;
+
+    /**
+     * Get the number of elements in the object dictionary.
+     *
+     * @return The number of elements in the object dictionary
+     */
+    uint8_t getNumElements() override;
+
+private:
+    DEV::HallSensor* hallSensors[NUM_HALLSENSORS]{};
+
+    uint32_t wheelSpeeds[NUM_HALLSENSORS] = {0, 0};
+
+    /**
+     * Object Dictionary Size
+     */
+    static constexpr uint16_t OBJECT_DICTIONARY_SIZE = 24;
+
+    /**
+     * CAN Open object dictionary
+     */
+    CO_OBJ_T objectDictionary[OBJECT_DICTIONARY_SIZE + 1] = {
+        MANDATORY_IDENTIFICATION_ENTRIES_1000_1014,
+        HEARTBEAT_PRODUCER_1017(2000),
+        IDENTITY_OBJECT_1018,
+        SDO_CONFIGURATION_1200,
+
+        // TPDO 0 CONFIGURATION
+        TRANSMIT_PDO_SETTINGS_OBJECT_18XX(0x00, TRANSMIT_PDO_TRIGGER_TIMER, TRANSMIT_PDO_INHIBIT_TIME_DISABLE, 2000),
+
+        // TPDO 0 MAPPING
+        TRANSMIT_PDO_MAPPING_START_KEY_1AXX(0, 2),
+        TRANSMIT_PDO_MAPPING_ENTRY_1AXX(0x00, 1, PDO_MAPPING_UNSIGNED16),
+        TRANSMIT_PDO_MAPPING_ENTRY_1AXX(0x00, 2, PDO_MAPPING_UNSIGNED16),
+
+        // TPDO 0 DATA LINKS
+        DATA_LINK_START_KEY_21XX(0, 2),
+        DATA_LINK_21XX(0x00, 1, CO_TUNSIGNED16, (uintptr_t) wheelSpeeds[0]),
+        DATA_LINK_21XX(0x00, 2, CO_TUNSIGNED16, (uintptr_t) wheelSpeeds[1]),
+
+        CO_OBJ_DICT_ENDMARK,
+    };
+};
+
+}// namespace WSS

include/dev/HallSensor.hpp

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <EVT/io/GPIO.hpp>
+
+namespace IO = EVT::core::IO;
+
+namespace WSS::DEV {
+
+class HallSensor {
+
+public:
+    enum WheelSpeedState {
+        STOP = 0,        // First pulse or wheel is dead
+        INITIALIZING = 1,// Setting speed based on first reading
+        MAINTAIN = 2,    // 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);
+
+    void update();// Update the wheel speed
+
+    // Get the current speed of the wheel
+    uint32_t getSpeed();
+
+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 lastInterval;// Last fully measured interval
+    WheelSpeedState state;// Current state of the wheel
+    bool magnetInLastRead;// Flag to check if the sensor is high
+
+    IO::GPIO::State MAGNET_DETECTED_STATE = IO::GPIO::State::LOW;
+};
+
+}// namespace WSS::DEV

src/WSS.cpp

@@ -0,0 +1,29 @@
+#include <WSS.hpp>
+
+namespace WSS {
+
+WSS::WSS(DEV::HallSensor& hallSensor1, DEV::HallSensor& hallSensor2) {
+    this->hallSensors[0] = &hallSensor1;
+    this->hallSensors[1] = &hallSensor2;
+}
+
+CO_OBJ_T* WSS::getObjectDictionary() {
+    return objectDictionary;
+}
+
+void WSS::process() {
+    for (uint8_t i = 0; i < NUM_HALLSENSORS; i++) {
+        hallSensors[i]->update();
+        wheelSpeeds[i] = hallSensors[i]->getSpeed();
+    }
+}
+
+uint8_t WSS::getNodeID() {
+    return NODE_ID;
+}
+
+uint8_t WSS::getNumElements() {
+    return OBJECT_DICTIONARY_SIZE;
+}
+
+}// namespace WSS

src/dev/HallSensor.cpp

@@ -0,0 +1,93 @@
+#include <EVT/io/GPIO.hpp>
+#include <HALf3/stm32f3xx_hal.h>
+#include <dev/HallSensor.hpp>
+
+namespace IO = EVT::core::IO;
+
+// TODO Tune these values
+constexpr uint32_t THRESHOLD = 10000;// Threshold for wheel speed
+constexpr uint32_t THETA = 2;        // Constant for wheel speed calculation
+
+namespace WSS::DEV {
+
+HallSensor::HallSensor(IO::GPIO& gpio, uint32_t wheelRadius) : gpio((IO::GPIO&) gpio), wheelRadius(wheelRadius) {
+    this->prevTime = 0;
+    this->lastInterval = 0;
+    this->state = WheelSpeedState::STOP;
+    this->magnetInLastRead = false;
+}
+
+void HallSensor::update() {
+    uint32_t now = HAL_GetTick();
+
+    switch (state) {
+    case WheelSpeedState::STOP:
+        if (gpio.readPin() == MAGNET_DETECTED_STATE) {
+            // If the magnet is detected for the first time, record the time and start initializing
+            if (!magnetInLastRead) {
+                prevTime = now;
+                magnetInLastRead = true;
+                state = WheelSpeedState::INITIALIZING;
+            }
+        } else {
+            magnetInLastRead = false;
+        }
+        break;
+
+    case WheelSpeedState::INITIALIZING:
+        if (gpio.readPin() == MAGNET_DETECTED_STATE) {
+            if (!magnetInLastRead) {
+                // If the magnet is detected for the second time, record the time and the first
+                // interval and start maintaining
+                lastInterval = now - prevTime;
+                prevTime = now;
+                magnetInLastRead = true;
+                state = WheelSpeedState::MAINTAIN;
+            }
+        } else {
+            magnetInLastRead = false;
+        }
+
+        // If the magnet hasn't been detected for a significant amount of time, go back to the stop
+        // state
+        if (now - prevTime > THRESHOLD) {
+            state = WheelSpeedState::STOP;
+            prevTime = 0;
+        }
+        break;
+
+    case WheelSpeedState::MAINTAIN:
+        if (gpio.readPin() == MAGNET_DETECTED_STATE) {
+            if (!magnetInLastRead) {
+                // If the magnet is newly detected, record the time and interval
+                lastInterval = now - prevTime;
+                prevTime = now;
+                magnetInLastRead = true;
+            }
+        } else {
+            magnetInLastRead = false;
+        }
+
+        uint32_t elapsedTime = now - prevTime;
+        // If the magnet hasn't been detected for a significant amount of time, go back to the stop
+        // state
+        if (elapsedTime > THRESHOLD) {
+            state = WheelSpeedState::STOP;
+            prevTime = 0;
+            lastInterval = 0;
+            // If the elapsed time since the magnet was last detected exceeds the last interval, record
+            // the last interval as if the magnet was just detected because the bike is slowing
+            // down, but the exact speed can't be calculated
+        } else if (elapsedTime > lastInterval) {
+            lastInterval = elapsedTime;
+        }
+        break;
+    }
+}
+
+uint32_t HallSensor::getSpeed() {
+    // TODO Calculate speed
+    return lastInterval;
+}
+
+}// namespace WSS::DEV