Merge branch 'development' into CenterAligned

Author: jmaralo

Inc/C++Utilities/RingBuffer.hpp

@@ -2,79 +2,64 @@
 
 #include "CppImports.hpp"
 
+template <typename T, size_t N>
+class RingBuffer {
+    std::array<T, N> buffer{};
 
-/**
- * @brief a Buffer class that acts as a RingBuffer using FIFO behaviour
- */
-template <typename item_type, size_t N>
-class RingBuffer{
-public:
-	RingBuffer(): msize(0), mcapacity(N), mhead_index(0), mlast_index(N){}
-
-
-	/**
-	 * @brief introduces a new item on the Ring Buffer unless it is full. Returns false when the Ring Buffer is full.
-	 */
-	bool push(item_type item){
-		if(msize == mcapacity){
-			return false;
-		}
-
-		msize++;
-		mlast_index++;
-		if(mlast_index >= mcapacity){
-			mlast_index = 0;
-		}
-
-		buffer[mlast_index] = item;
-		return true;
-	}
-
-
-	bool is_empty(){return msize == 0;}  /**< @brief returns true when RingBuffer is empty, false otherwise.*/
-	bool is_full(){return msize == mcapacity;}  /**< @brief returns true when RingBuffer is full, false otherwise.*/
-	uint32_t size(){return msize;}	/**< @brief returns the occupied size of the RingBuffer.*/
-
-
-
-
-	/**
-	 * @brief checks the next variable to read without removing it from the buffer. Do not use on empty buffer.
-	 */
-	item_type peek(){
-		return buffer[mhead_index];
-	}
-
-	/**
-	 * @brief checks the next variable to read and removes it from the buffer. Do not use on empty buffer.
-	 */
-	item_type pop(){
-		uint32_t return_index = mhead_index;
-		mhead_index++;
-		msize--;
-		if(mhead_index >= mcapacity){
-			mhead_index = 0;
-		}
-		return buffer[return_index];
-	}
-
-	/**
-	 * @brief pop later and push new. Don't care size of buffer, needs to be initialize before
-	 */
-	void push_pop(item_type item){
-		mhead_index = (mhead_index+1)%mcapacity;
-		mlast_index = (mlast_index+1)%mcapacity;
-		buffer[mhead_index] = item;
-	}
-
-	item_type latest()const{
-		return buffer[mlast_index];
-	}
-
-private:
-	std::array<item_type, N> buffer;
-	uint32_t msize;
-	uint32_t mcapacity;
-	uint32_t mhead_index;
-	uint32_t mlast_index;
+    size_t stored_items{0};
+
+    size_t front{0};
+    size_t back{0};
+
+    size_t move_forward(size_t origin, size_t amount) {
+        return (origin + amount) % N;
+    }
+
+    size_t move_backward(size_t origin, size_t amount) {
+        // N * ((amount / N) + 1) makes it so that the operation doesn't
+        // overflow (size_t is unsigned) and with the help of modular
+        // arithmetic, this won't change the result
+        return ((origin + (N * ((amount / N) + 1))) - amount) % N;
+    }
+
+   public:
+    RingBuffer() {}
+
+    bool push(T item) {
+        if (is_full()) return false;
+
+        buffer[front] = item;
+        front = move_forward(front, 1);
+        ++stored_items;
+
+        return true;
+    }
+
+    bool pop() {
+        if (is_empty()) return false;
+
+        back = move_forward(back, 1);
+        --stored_items;
+
+        return true;
+    }
+
+    bool push_pop(T item) {
+        if (is_empty()) return false;
+
+        buffer[front] = item;
+        front = move_forward(front, 1);
+        back = move_forward(back, 1);
+
+        return true;
+    }
+
+    T &operator[](size_t index) {
+        return buffer[move_backward(front, index + 1)];
+    }
+
+    constexpr size_t capacity() { return N; }
+    size_t size() { return stored_items; }
+    bool is_full() { return size() >= capacity(); }
+    bool is_empty() { return size() == 0; }
 };

Inc/HALAL/Services/DigitalOutputService/DigitalOutputService.hpp

@@ -7,14 +7,15 @@
 #pragma once
 #include "HALAL/Models/PinModel/Pin.hpp"
 
-class DigitalOutputService{
-public:
-	static map<uint8_t,Pin> service_ids;
-	static uint8_t id_counter;
+class DigitalOutputService {
+   public:
+    static map<uint8_t, Pin> service_ids;
+    static uint8_t id_counter;
 
-	static uint8_t inscribe(Pin& pin);
-	static void turn_on(uint8_t id);
-	static void turn_off(uint8_t id);
-	static void set_pin_state(uint8_t id, PinState state);
-	static void toggle(uint8_t id);
+    static uint8_t inscribe(Pin& pin);
+    static void turn_on(uint8_t id);
+    static void turn_off(uint8_t id);
+    static void set_pin_state(uint8_t id, PinState state);
+    static void toggle(uint8_t id);
+    static bool lock_pin_state(uint8_t id, PinState state);
 };

Inc/HALAL/Services/Watchdog/Watchdog.hpp

@@ -1,36 +1,36 @@
 #pragma once
-#include "HALAL/Models/PinModel/Pin.hpp"
 #include "C++Utilities/CppUtils.hpp"
 #include "ErrorHandler/ErrorHandler.hpp"
-
+#include "HALAL/Models/PinModel/Pin.hpp"
 
 extern IWDG_HandleTypeDef watchdog_handle;
-
+extern bool reset_by_iwdg;
 
 /**
  * @brief The watchdog class resets the board when it gets stuck inside a loop
  *
- * To ensure that the code its not stuck, the refresh function must be called at least once each period
- * Otherwise, the Watchdog will reset the board. The Watchdog its not active until it is started.
+ * To ensure that the code is not stuck, the refresh function must be called at
+ * least once every period; otherwise, the Watchdog will reset the board. The
+ * Watchdog is not active until it is started.
  */
-class Watchdog{
-public:
-
-    template<typename TimeUnit>
-    static void start(chrono::duration<int64_t, TimeUnit> period){
-    	if((chrono::duration_cast<chrono::microseconds>(period)).count() > 32000000){
-    		ErrorHandler("Watchdog refresh interval is too big");
-    	}
-    	if((chrono::duration_cast<chrono::microseconds>(period)).count() < 125){
-    		ErrorHandler("Watchdog refresh interval is too short");
-    	}
-        uint64_t microseconds = chrono::duration_cast<chrono::microseconds>(period).count();
-        uint32_t RL = (uint64_t)((double) microseconds / 4 / 31.25) - 1;
+class Watchdog {
+   public:
+    static std::chrono::microseconds watchdog_time;
+    
+    static void start() {
+        if ((chrono::duration_cast<chrono::microseconds>(watchdog_time)).count() > 32000000) {
+            ErrorHandler("Watchdog refresh interval is too big");
+        }
+        if ((chrono::duration_cast<chrono::microseconds>(watchdog_time)).count() < 125) {
+            ErrorHandler("Watchdog refresh interval is too short");
+        }
+        uint64_t milliseconds = chrono::duration_cast<chrono::milliseconds>(watchdog_time).count();
+        uint32_t RL = double(milliseconds) * 8.0 - 1; // this is the formula for the Reload
         uint32_t prescaler = 0;
-
-        while(RL > 4095){
-        	microseconds /= 2;
-        	prescaler += 1;
+        while (RL > 4095) {
+            milliseconds /= 2;
+            prescaler += 1;
+            RL = double(milliseconds) * 8.0 - 1;
         }
 
         watchdog_handle.Instance = IWDG1;
@@ -40,8 +40,18 @@ class Watchdog{
         HAL_IWDG_Init(&watchdog_handle);
     }
 
-    static inline void refresh(){
-    	__HAL_IWDG_RELOAD_COUNTER(&watchdog_handle);
+    static void refresh() {
+        HAL_IWDG_Refresh(&watchdog_handle);
+    }
+    static void check_reset_flag(){
+        if (__HAL_RCC_GET_FLAG(RCC_FLAG_IWDG1RST)) {
+            reset_by_iwdg = true;
+            
+        }
+        __HAL_RCC_CLEAR_RESET_FLAGS();
+    }
+    template <typename TimeUnit>
+    Watchdog(chrono::duration<int64_t, TimeUnit> period) {
+        watchdog_time = std::chrono::duration_cast<std::chrono::microseconds>(period);
     }
-
 };

Inc/HALALMock/Services/DigitalOutputService/DigitalOutputService.hpp

@@ -19,4 +19,5 @@ class DigitalOutputService {
     static void turn_off(uint8_t id);
     static void set_pin_state(uint8_t id, PinState state);
     static void toggle(uint8_t id);
+    static bool lock_pin_state(uint8_t id, PinState state);
 };

Inc/ST-LIB.hpp

@@ -3,7 +3,6 @@
 #include "HALAL/HALAL.hpp" // Erase this when ST-LIB_LOW is finished.
 #include "ST-LIB_LOW.hpp"  // Erase this when ST-LIB_HIGH is finished
 #include "ST-LIB_HIGH.hpp" // Highest layer up to the moment
-
 class STLIB {
 public:
 

Inc/ST-LIB_LOW/DigitalOutput/DigitalOutput.hpp

@@ -10,17 +10,17 @@
 #include "HALAL/HALAL.hpp"
 
 class DigitalOutput {
-public:
-	DigitalOutput() = default;
-	DigitalOutput(Pin& pin);
-
-	void turn_on();
-	void turn_off();
-	void toggle();
-	void set_pin_state(PinState state);
-private:
-	Pin pin;
-	uint8_t id;
-};
+   public:
+    DigitalOutput() = default;
+    DigitalOutput(Pin& pin);
 
+    void turn_on();
+    void turn_off();
+    void toggle();
+    void set_pin_state(PinState state);
+    bool lock_pin_state(PinState state);
 
+   private:
+    Pin pin;
+    uint8_t id;
+};