Clang Tidy Workflow + Telemetry Clean Up

.github/workflows/clang-tidy.yml

@@ -0,0 +1,51 @@
+name: Clang-Tidy Check
+
+on:
+  #triggers the workflow on pull requests
+  pull_request:
+    branches:
+      - '**'
+
+  #allows manual triggering of the workflow
+  workflow_dispatch:
+
+jobs:
+  clang-tidy-check:
+    runs-on: ubuntu-latest
+
+    steps:
+      #gets the current repo
+      - name: Checkout Avionics repo
+        uses: actions/checkout@v4
+        with:
+          path: Avionics
+
+      #clones the native repo
+      - name: Clone Native repo
+        run: |
+          git clone https://github.com/CURocketEngineering/Native native
+
+      #replaces the linked Avionics repo with the current Avionics code
+      - name: Replace Native lib Avionics with checked-out Avionics code
+        run: |
+          rm -rf native/lib/Avionics
+          mkdir -p native/lib
+          mv Avionics native/lib/Avionics
+
+      #installed PlatformIO core
+      - name: Install PlatformIO Core
+        run: |
+          pip install -U platformio
+
+      #shows the file tree structure for debugging
+      - name: Show native directory structure
+        run: |
+          echo "===== native directory tree ====="
+          ls -R native
+
+      #runs clang-tidy check
+      - name: Run Clang-Tidy Check
+        working-directory: ./native
+        run: pio check --fail-on-defect=low --fail-on-defect=medium --fail-on-defect=high
+
+

hal/ArduinoHAL.h

@@ -3,30 +3,26 @@
 
 #ifdef ARDUINO
 #include "Arduino.h"
-#include <SPI.h>
-#include <Adafruit_Sensor.h>
 
 #include <Adafruit_SPIFlash.h>
+#include <Adafruit_Sensor.h>
 #include <SdFat.h>
 #include <SdFatConfig.h>
+#include <SPI.h>
 
 #else // Everything below will only be compiled if we are not on an Arduino
 
-#include <string>
-using String = std::string;
-
-#include <iostream>
-#include <cstring>
-
 #include <chrono>
-
-#include "spi_mock.h"
-
-// Within here we must define the mock functions for the Arduino functions
+#include <cstring>
+#include <iostream>
+#include <string>
 #include <thread>
 
 #include "Adafruit_SPIFlash_mock.h"
 #include "serial_mock.h"
+#include "spi_mock.h"
+
+using String = std::string;
 
 #define OUTPUT 1
 #define INPUT 0
@@ -55,4 +51,4 @@ inline void delay(unsigned long ms) { // NOLINT
 
 
 #endif // ARDUINO
-#endif // ARDUINOHAL_H
+#endif // ARDUINOHAL_H

include/data_handling/CircularArray.h

@@ -2,11 +2,14 @@
 #define CIRCULARARRAY_H
 
 #include <algorithm>
+#include <array>
+#include <assert.h>
 #include <cstdint>
-#include <vector>
 
-template<typename T>
-int partition(std::vector<T>& array, int left, int right, int pivotIndex) {
+constexpr std::size_t MAX_CIRCULAR_ARRAY_CAPACITY = 255;
+
+template<typename T, std::size_t N>
+int partition(std::array<T, N>& array, int left, int right, int pivotIndex) {
     T pivotValue = array[pivotIndex];
     std::swap(array[pivotIndex], array[right]); // Move pivot to end
     int storeIndex = left;
@@ -26,8 +29,8 @@ int partition(std::vector<T>& array, int left, int right, int pivotIndex) {
 // O(n) average time complexity
 // O(n^2) worst case time complexity
 // If we were to just use bubble sort, that would be O(n^2) time complexity
-template<typename T>
-T quickSelect(std::vector<T> &array, int left, int right, int k){
+template<typename T, std::size_t N>
+T quickSelect(std::array<T, N> &array, int left, int right, int k){
     while (left < right){
         int pivotIndex = (left + right) / 2;
         int pivotNewIndex = partition(array, left, right, pivotIndex);
@@ -43,46 +46,48 @@ T quickSelect(std::vector<T> &array, int left, int right, int k){
 }
 
 
-template<typename T>
+template<typename T, std::size_t Capacity>
 /**
  * @brief Fixed-size circular buffer with median helper and head tracking.
  * @note When to use: maintain a rolling window of recent samples for filters
  *       or detectors without reallocations.
  */
 class CircularArray {
   protected:
-    std::vector<T> array; 
-    uint8_t head;       // 0 to 255
+    std::array<T, Capacity> array; 
+    std::array<T, Capacity> scratchArray; // For median calculation
     uint8_t maxSize;    // 0 to 255
-    uint16_t pushCount; // 0 to 65535
+    uint8_t head;       // 0 to 255
+    uint8_t currentSize; // 0 to 255
 
   public:
-    CircularArray(uint8_t maxSize){
-        this->maxSize = maxSize;
+    CircularArray(uint8_t maxSize = Capacity) : maxSize(maxSize) {
+        static_assert(Capacity > 0, "CircularArray capacity must be greater than 0");
+        static_assert(Capacity <= MAX_CIRCULAR_ARRAY_CAPACITY, "CircularArray capacity must be less than or equal to 255 b/c of head being uint8_t");
+        assert(maxSize > 0 && maxSize <= Capacity);
         this->head = 0;
-        this->pushCount = 0;
-        this->array = std::vector<T>(maxSize, T());
-    }
-
-    ~CircularArray(){
-        array.clear();
+        this->currentSize = 0; // How full is the circular buffer? 
     }
 
     void push(T data){
         // After the first push, start moving the head
-        if (pushCount)
+        if (currentSize)
             head = (head + 1) % maxSize;
         array[head] = data;
-        pushCount++;
+
+        // Cap current size at maxSize
+        if (currentSize < maxSize){
+            currentSize++;
+        }
     }
 
     T pop(){
-        if (pushCount == 0){
+        if (currentSize == 0){
             return T();
         }
         T data = array[head];
         head = (head + maxSize - 1) % maxSize;
-        pushCount--;
+        currentSize--;
         return data;
     }
 
@@ -93,11 +98,11 @@ class CircularArray {
 
     // Has the circular array been filled          
     bool isFull(){
-        return pushCount >= maxSize;
+        return currentSize >= maxSize;
     }
 
     bool isEmpty(){
-        return pushCount == 0;
+        return currentSize == 0;
     }
 
     uint8_t getHead(){
@@ -109,28 +114,27 @@ class CircularArray {
     }
 
     T getMedian(){
-        if (pushCount == 0) {
+        if (currentSize == 0) {
         // Handle the case when the array is empty
         return T();
         }
 
-        size_t count = std::min(static_cast<size_t>(pushCount), static_cast<size_t>(maxSize));
-        std::vector<T> copyArray(count);
+        size_t count = std::min(static_cast<size_t>(currentSize), static_cast<size_t>(maxSize));
 
         // Collect the valid elements from the circular array
-        // TODO: Optimize (or just copy everything and restrict this function to only running when the array is full)
         for (size_t i = 0; i < count; ++i) {
-            copyArray[i] = array[(head + maxSize - i) % maxSize];
+            scratchArray[i] = array[(head + maxSize - i) % maxSize];
         }
 
         // Find the median
-        return quickSelect(copyArray, 0, count - 1, count / 2);
+        int n = static_cast<int>(count);
+        return quickSelect(scratchArray, 0, n - 1, n / 2);
     }
 
     void clear(){
         head = 0;
-        pushCount = 0;
-        for (int i = 0; i < maxSize; i++){
+        currentSize = 0;
+        for (uint8_t i = 0; i < maxSize; i++){
             array[i] = T();
         }
     }
@@ -139,4 +143,4 @@ class CircularArray {
 
 
 
-#endif
+#endif

include/data_handling/DataSaver.h

@@ -53,6 +53,11 @@ class IDataSaver {
             // Default implementation does nothing
         }
 
+        // default method that does nothing, can be overridden
+        virtual void clearPostLaunchMode(){
+            // default implementation does nothing
+        }
+
 };