Introduce Modern C++ to the Arduino Framework

.github/workflows/clang-tidy.yml

@@ -0,0 +1,27 @@
+on:
+  pull_request:
+    types:
+      - opened
+      - review_requested
+
+permissions:
+  contents: read
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: cpp-linter/cpp-linter-action@v2
+        id: linter
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          style: 'file'  # Use .clang-format config file
+          tidy-checks: '' # Use .clang-tidy config file
+          # only 'update' a single comment in a pull request's thread.
+          thread-comments: ${{ github.event_name == 'pull_request' && 'update' }}
+      - name: Fail fast?!
+        if: steps.linter.outputs.checks-failed > 0
+        run: exit 1

.gitignore

@@ -1,2 +1,4 @@
 .idea
+.pio
 cmake-build-debug
+main.cpp

CMakeLists.txt

@@ -1,20 +1,2 @@
 cmake_minimum_required(VERSION 3.28)
-project(LEADS_Arduino)
-
-set(CMAKE_CXX_STANDARD 14)
-
-include_directories(src)
-
-add_executable(LEADS_Arduino
-        src/ArrayList.h
-        src/Controller.cpp
-        src/Controller.h
-        src/Device.h
-        src/LEADS.h
-        src/PredefinedTags.h
-        src/Utils.cpp
-        src/Utils.h
-        src/VoltageSensor.cpp
-        src/VoltageSensor.h
-        src/WheelSpeedSensor.cpp
-        src/WheelSpeedSensor.h)
+project(LEADS-Arduino C CXX)

keywords.txt

@@ -6,6 +6,7 @@ WheelSpeedSensor KEYWORD1
 pulseTriggered KEYWORD2
 equivalent KEYWORD2
 returnFloat KEYWORD2
+returnDouble KEYWORD2
 LEFT_FRONT_WHEEL_SPEED_SENSOR LITERAL1
 RIGHT_FRONT_WHEEL_SPEED_SENSOR LITERAL1
 CENTER_REAR_WHEEL_SPEED_SENSOR LITERAL1

platformio.ini

@@ -0,0 +1,14 @@
+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+[env:micro]
+platform = atmelavr
+board = nanoatmega328new
+framework = arduino

src/ArrayList.h

@@ -6,40 +6,55 @@
 
 template<typename E>
 class ArrayList {
-private:
-    int _size;
+protected:
+    size_t _size, _capacity;
     E *_array;
     void grow(size_t minCapacity) {
-        int oldCapacity = _array.length;
-        int newCapacity = oldCapacity + (oldCapacity >> 1);
+        size_t newCapacity = _capacity + (_capacity >> 1);
         if (newCapacity < minCapacity)
             newCapacity = minCapacity;
-        E newArray = new E[newCapacity];
-        copy(begin(_array), end(_array), begin(newArray));
+        E *newArray = new E[newCapacity];
+        memmove(newArray, _array, _size * sizeof(E));
+        delete[] _array;
         _array = newArray;
+        _capacity = newCapacity;
     }
     void ensureExplicitCapacity(size_t minCapacity) {
-        if (minCapacity > _array.length)
+        if (minCapacity > _capacity)
             grow(minCapacity);
     }
-    void ensureCapacityInternal(size_t minCapacity) {
-        if (_array.length == 0)
-            minCapacity = max(10, minCapacity);
-        ensureExplicitCapacity(minCapacity);
+    void ensureCapacityInternal(size_t minCapacity) { ensureExplicitCapacity(max(10, minCapacity)); }
+    void add(E *elements, size_t size) {
+        ensureCapacityInternal(_size + size);
+        memcpy(_array + _size, elements, size * sizeof(E));
     }
 
 public:
-    ArrayList(size_t initialCapacity = 10) : _size(0), _array(new E[initialCapacity]) {}
-    ArrayList(E *const initialArray) : _size(0), _array(initialArray) {}
+    explicit ArrayList(size_t initialCapacity = 10) :
+        _size(0), _capacity(initialCapacity), _array(new E[initialCapacity]) {}
+    ArrayList(E const *const initialArray, size_t size) : _size(0), _capacity(size), _array(new E[size]) {
+        memcpy(_array, initialArray, size * sizeof(E));
+    }
+    ArrayList(const ArrayList<E> &other) : ArrayList(other._array, other._size) {}
     ~ArrayList() { delete[] _array; }
     int size() { return _size; }
-    E *const &toArray() { return _array; }
+    E const *toArray() { return _array; }
+    void set(int index, E element) { _array[index] = element; }
     E get(int index) { return _array[index]; }
+    void clear() {
+        delete[] _array;
+        _array = new E[0];
+        _size = _capacity = 0;
+    }
     void add(E element) {
         ensureCapacityInternal(_size + 1);
         _array[_size++] = element;
     }
-    bool insert(int index, E element);
+    ArrayList<E> add(const ArrayList<E> &other) {
+        ArrayList<E> result = copy();
+        result.add(other._array, other._size);
+        return result;
+    }
     bool contains(E element) { return indexOf(element) >= 0; }
     int indexOfInRange(E element, int start, int stop) {
         for (int i = start; i < stop; i++)
@@ -55,6 +70,15 @@ class ArrayList {
         return -1;
     }
     int lastIndexOf(E element) { return lastIndexOfInRange(element, 0, _size); }
+    ArrayList<E> copy() { return ArrayList<E>(this); }
+    ArrayList<E> operator+(const ArrayList<E> &other) { return add(other); }
+    ArrayList<E> &operator=(const ArrayList<E> &other) {
+        if (this != &other) {
+            ensureCapacityInternal(other._capacity);
+            memcpy(_array, other._array, _size * sizeof(E));
+        }
+        return *this;
+    }
 };
 
 

src/Controller.h

@@ -4,17 +4,30 @@
 
 #include "Device.h"
 
-template<typename T>
+template<typename T, typename E>
 class Controller : public Device<T> {
 protected:
-    ArrayList<Device<String>> _devices;
-    void _attachDevice(String tag, Device<String> device);
+    ArrayList<String> _device_tags;
+    ArrayList<Device<E>> _devices;
+    void _attachDevice(String &tag, Device<E> device) {
+        _device_tags.add(tag);
+        _devices.add(device);
+        device.tag(tag);
+    }
 
 public:
-    Controller();
-    int level();
-    void device(String tag, Device<String> device);
-    Device<String> device(String tag);
+    Controller() : Device<T>() {}
+    int level() { return this->_parentTags.size(); }
+    void device(const String &tag, Device<E> device) { _attachDevice(tag, device); }
+    Device<E> device(const String &tag) { return _devices.get(_device_tags.indexOf(tag)); }
+    virtual void initialize(const ArrayList<String> &parentTags) {
+        Device<E>::initialize(parentTags);
+        for (Device<E> d: _devices) {
+            ArrayList<String> deviceParentTags = this->_parentTags.copy();
+            deviceParentTags.add(this->_tag);
+            d.initialize(deviceParentTags);
+        }
+    }
 };
 
 

src/Device.h

@@ -8,24 +8,20 @@ template<typename T>
 class Device {
 protected:
     String _tag = "";
-    ArrayList<String> _parentTags();
-    int *const _pins;
+    ArrayList<String> _parentTags = ArrayList<String>();
+    ArrayList<int> _pins;
 
 public:
-    Device(int *const pins) : _pins(pins) {}
-    ~Device() { delete[] _pins; }
-    void tag(String tag) { _tag = tag; }
+    explicit Device(const ArrayList<int> &pins) : _pins(pins) {}
+    ~Device() = default;
+    void tag(const String &tag) { _tag = tag; }
     String tag() { return _tag; }
-    void parentTags(ArrayList<String> parentTags) { _parentTags = parentTags; }
-    ArrayList<String> parentTags() { return _parentTags; }
-    void pinsCheck(int requiredNum) {
-        if (sizeof(_pins) != requiredNum)
-            throw value_error(format("This device only takes in {} pins", requiredNum));
-    }
-    void initialize(String *parentTags);
-    T read();
-    void write(T payload);
-    void close();
+    void parentTags(const ArrayList<String> &parentTags) { _parentTags = parentTags; }
+    const ArrayList<String> &parentTags() { return _parentTags; }
+    virtual void initialize(const ArrayList<String> &parentTags) { _parentTags = parentTags; }
+    virtual T read() = 0;
+    virtual void write(T payload) {}
+    virtual void close() {}
 };
 
 

src/Utils.cpp

@@ -2,12 +2,18 @@
 
 bool pulseTriggered(int pin) { return digitalRead(pin) == LOW; }
 
-bool equivalent(float a, float b, float epsilon) { return fabs(a - b) <= epsilon * max(fabs(a), fabs(b)); }
+bool equivalent(float a, float b, float epsilon) { return abs(a - b) <= epsilon * max(abs(a), abs(b)); }
 
-bool equivalent(long a, long b, float epsilon) { return fabs(a - b) <= epsilon * max(fabs(a), fabs(b)); }
+bool equivalent(long a, long b, float epsilon) { return labs(a - b) <= epsilon * max(labs(a), labs(b)); }
 
-void returnFloat(String header, float n) {
-	Serial.print(header + ":");
+void returnFloat(const String &tag, float n) {
+    Serial.print(tag + ":");
+    Serial.print(n);
+    Serial.print(";");
+}
+
+void returnDouble(const String &tag, double n) {
+    Serial.print(tag + ":");
     Serial.print(n);
     Serial.print(";");
 }

src/Utils.h

@@ -10,7 +10,9 @@ bool equivalent(long a, long b, float epsilon);
 
 bool equivalent(float a, float b, float epsilon);
 
-void returnFloat(String header, float n);
+void returnFloat(const String &tag, float n);
+
+void returnDouble(const String &tag, double n);
 
 
 #endif // UTILS_H

src/VoltageSensor.cpp

@@ -1,7 +1,11 @@
 #include "VoltageSensor.h"
 
-VoltageSensor::VoltageSensor(float r1, float r2, int *const pins) : _factor((r1 + r2) / r2), Device<float>(pins) {}
+VoltageSensor::VoltageSensor(float r1, float r2, const ArrayList<int> &pins) :
+    Device<float>(pins), _factor((r1 + r2) / r2) {}
 
-void VoltageSensor::initialize() { pinMode(_pins[0], INPUT); }
+void VoltageSensor::initialize(const ArrayList<String> &parentTags) {
+    Device<float>::initialize(parentTags);
+    pinMode(_pins.get(0), INPUT);
+}
 
-float VoltageSensor::read() { return (float) analogRead(_pins[0]) * _factor * 5 / 1023; }
+float VoltageSensor::read() { return (float) analogRead(_pins.get(0)) * _factor * 5 / 1023; }

src/VoltageSensor.h

@@ -7,11 +7,12 @@
 class VoltageSensor : public Device<float> {
 protected:
     float _factor;
+
 public:
-    VoltageSensor(float r1, float r2, int *const pins);
-    void initialize();
-    float read();
+    VoltageSensor(float r1, float r2, const ArrayList<int> &pins);
+    void initialize(const ArrayList<String> &parentTags) override;
+    float read() override;
 };
 
 
-#endif //VOLTAGESENSOR_H
+#endif // VOLTAGESENSOR_H

src/WheelSpeedSensor.cpp

@@ -1,22 +1,21 @@
 #include "WheelSpeedSensor.h"
 #include "Utils.h"
 
-WheelSpeedSensor::WheelSpeedSensor(int *const pins, OnUpdate onUpdate) : Device<float>(pins), _onUpdate(onUpdate) {
-}
+WheelSpeedSensor::WheelSpeedSensor(const ArrayList<int> &pins, OnUpdate onUpdate) :
+    Device<float>(pins), _t1(0), _t2(0), _consecutive(false), _onUpdate(onUpdate) {}
 
-void WheelSpeedSensor::initialize() {
-    pinMode(_pins[0], INPUT);
+void WheelSpeedSensor::initialize(const ArrayList<String> &parentTags) {
+    Device<float>::initialize(parentTags);
+    pinMode(_pins.get(0), INPUT);
     _t1 = 0;
     _t2 = millis();
     _consecutive = false;
 }
 
-float getRPM(long t1, long t2) {
-    return 60000.0 / (t2 - t1);
-}
+float getRPM(unsigned long t1, unsigned long t2) { return float(60000.0 / double(t2 - t1)); }
 
 float WheelSpeedSensor::read() {
-    if (pulseTriggered(_pins[0])) {
+    if (pulseTriggered(_pins.get(0))) {
         if (!_consecutive) {
             _consecutive = true;
             _t1 = _t2;
@@ -25,10 +24,7 @@ float WheelSpeedSensor::read() {
             _onUpdate(r);
             return r;
         }
-    } else _consecutive = false;
+    } else
+        _consecutive = false;
     return getRPM(_t1, _t2);
 }
-
-String WheelSpeedSensor::debug() {
-    return String(_t1) + " " + String(_t2);
-}

src/WheelSpeedSensor.h

@@ -8,15 +8,14 @@ typedef void (*OnUpdate)(float ws);
 
 class WheelSpeedSensor : public Device<float> {
 protected:
-    long _t1, _t2;
+    unsigned long _t1, _t2;
     bool _consecutive;
     const OnUpdate _onUpdate;
 
 public:
-    WheelSpeedSensor(int *const pins, OnUpdate onUpdate);
-    void initialize();
-    float read();
-    String debug();
+    WheelSpeedSensor(const ArrayList<int> &pins, OnUpdate onUpdate);
+    void initialize(const ArrayList<String> &parentTags) override;
+    float read() override;
 };
 
 

test/ArrayList.cpp

@@ -0,0 +1,13 @@
+#include "LEADS.h"
+
+ArrayList<int> test = ArrayList<int>();
+
+void setup() { Serial.begin(9600); }
+
+void loop() {
+    test.add(1);
+    if (test.size() > 20)
+        test.clear();
+    Serial.println(test.size());
+    delay(100);
+}