Feature/86dregyz4/circular queue

Common/Inc/circ_queue.h

@@ -6,31 +6,14 @@
 // define Queue structure
 typedef struct {
     size_t len;
-    CANFrames_t _arr[BUFF_SIZE];
-    size_t _head;
-    size_t _tail;
+    CAN_Frame_t _arr[BUFF_SIZE];
+    size_t* _head;
+    size_t* _tail;
 } Queue_t;
 
-// macro _INC_HEAD for _head increment
-#define _INC_HEAD(self) {                   \
-    if (self->_head == (BUFF_SIZE - 1)){   \
-        self->_head = 0                     \
-    } else {                                \
-        self->_head += 1;                   \
-    }                                       \
-}
-
-// macro _INC_TAIL for _tail indexing
-#define _INC_TAIL(self) {                   \
-    if (self->_tail == (BUFF_SIZE - 1)) {  \
-        self->_tail = 0;                    \
-    } else {                                \
-        self->_tail += 1;                   \
-    }                                       \
-}
-
-Queue_t Queue_init() // intialize new and empty queue structure
-uint8_t Queue_empty (Queue_t* self); // check if queue is empty
-void Queue_add(Queue_t* self, CAN_Frame_t val); // add a frame to queue
-CAN_Frame_t Queue_get(Queue* self); // remove and return head frame
-void Queue_print(Queue_t* self); // print queue
+Queue_t queue_init(); // intialize new and empty queue structure
+uint8_t queue_empty (Queue_t self); // check if queue is empty
+uint8_t queue_full(Queue_t self);
+void queue_add(Queue_t* self, CAN_Frame_t val); // add a frame to queue
+CAN_Frame_t queue_get(Queue_t* self); // remove and return head frame
+void queue_print(Queue_t* self); // print queue

Common/Src/circ_queue.c

@@ -1,61 +1,88 @@
 #include <stdio.h>
-#include "config.h"
-#include "can_driver.h"
 #include "circ_queue.h"
 
-// intializes and return a queue with zero length and head/tail indices
-Queue_t Queue_init() {
-    Queue_t ret = {
-        .len = 0,
-        ._head = 0,
-        ._tail = 0,
-        ._arr = {{0}}
-    };
-    return ret
+static void inc_head(Queue_t *self)
+{
+    if (++self->_head >= self->_arr + BUFF_SIZE)
+    {
+        self->_head = self->_arr;
+    }
+}
+
+static void inc_tail(Queue_t *self)
+{
+    if (++self->_tail >= self->_arr + BUFF_SIZE)
+    {
+        self->_tail = self->_arr;
+    }
+}
+
+Queue_t queue_init()
+{
+    Queue_t ret;
+    ret.len = 0;
+    ret._head = ret._arr;
+    ret._tail = ret._arr;
+    return ret;
 }
 
 // empty queue, returns 1 if true, 0 if false
-uint8_t Queue_empty(Quene_t* self) {
-    return self->len == 0;
+uint8_t queue_empty(Queue_t self)
+{
+    return self.len == 0;
+}
+
+// Check if queue is full
+uint8_t queue_full(Queue_t self)
+{
+    return self.len == BUFF_SIZE;
 }
 
 // adds new CANFrame to queue
-void Queue_add(Queue_t* self, CAN_Frame_t frame) {
-    if ( !(self->len == BUFF_SIZE) ) {
-        if (Queue_empty(self)) {
-            self->_arr[self->_head] = frame;
-        }
-        else {
-            _INC_TAIL(self);
-            self->_arr[self->_tail] = frame;
+void Queue_add(Queue_t *self, CAN_Frame_t frame)
+{
+    if (!queue_full(*self))
+    {
+        *self->_tail = frame;
+        inc_tail(self);
+        if (queue_empty(*self))
+        {
+            self->_head = self->_tail; // If adding first element, head and tail should point to the same place
         }
-        self->len += 1;
+        self->len++;
     }
-    else {
-        self->_arr[self->_head] = val;
-        _INC_HEAD(self);
-        _INC_TAIL(self);
+    else
+    {
+        // Handle the queue being full, if necessary
     }
 }
 
 // removes frame from queue
-CAN_Frame_t Queue_get(Queue_t* self) {
-    if (self->len == 0) {
-        CAN_Frame_t ret = {
-
-        }
+CAN_Frame_t queue_get(Queue_t *self)
+{
+    CAN_Frame_t ret;
+    if (self->len == 0)
+    {
+        ret.id = 0xFFFFFFFF; // frame id init to 0xFFFFFFFF
     }
-    else { 
-        CAN_Frame_t ret = self->_arr[self->_head];
-        _INC_HEAD(self);
-        self->len -= 1;
-        return ret
+    else
+    {
+        ret = *self->_head;
+        inc_head(self);
+        self->len--;
     }
+    return ret;
 }
-
-//print
-void Queue_print(Queue_t* self) {
-    for (size_t i = 0; i < (BUFF_SIZE - 1); i++) {
-        printf(self->_arr[i])
+// print
+void queue_print(Queue_t *self)
+{
+    CAN_Frame_t *current = self->_head;
+    for (size_t i = 0; i < self->len; i++)
+    {
+        printf("Frame ID: %u\n", current->id);
+        if (++current == self->_arr + BUFF_SIZE)
+        {
+            current = self->_arr;
+        }
     }
-}
+}