Merge pull request #21 from vas-dav/queue-manager

Queue manager

source/shoh/src/main.cpp

@@ -11,10 +11,25 @@ int main(void)
 {
   SystemCoreClockUpdate();
   Board_Init();
-  ThreadCommon::ThreadManager manager;
+  ThreadCommon::ThreadManager* manager = new ThreadCommon::ThreadManager;
-  manager.createTask(master_thread, "master",
+  ThreadCommon::QueueManager* qmanager = new ThreadCommon::QueueManager;
+  //Creating queues
+  qmanager->createQueue(100,
+                        sizeof(ThreadCommon::Event),
+                        ThreadCommon::QueueManager::master_event_all);
+
+  //Creating tasks
+  manager->createTask(master_thread, "master",
                      configMINIMAL_STACK_SIZE * 10,tskIDLE_PRIORITY + 1UL,
-                     nullptr);
+                     static_cast<void*>(qmanager));
+  
+  //<Queue_test>
+  QueueHandle_t master_event_all_q = qmanager->getQueue(ThreadCommon::QueueManager::master_event_all);
+  ThreadCommon::Event* e = new ThreadCommon::Event(ThreadCommon::Rotary, 1);
+
+  qmanager->send<ThreadCommon::Event>(ThreadCommon::QueueManager::master_event_all, e, 1000);
+  //</Queue_test>
+
   // Start the real time kernel with preemption.
   //FreeRTOS::Kernel::startScheduler();
   vTaskStartScheduler ();

source/shoh/src/threads/common/QueueManager.cpp

@@ -0,0 +1,32 @@
+/*
+ * QueueManager.cpp
+ *
+ *  Created on: 24 Apr 2023
+ *      Author: tylen
+ */
+
+#include "ThreadCommon.h"
+
+ThreadCommon::QueueManager::QueueManager() {}
+
+bool ThreadCommon::QueueManager::createQueue(size_t queue_length, size_t item_size, Queue_id qid)
+{
+    QueueHandle_t queue_to_create;
+    if ((queue_to_create = xQueueCreate(queue_length, item_size)))
+    {
+        queues.insert({qid, queue_to_create});
+        return true;
+    }
+    return false;
+}
+
+QueueHandle_t ThreadCommon::QueueManager::getQueue(Queue_id qid)
+{
+    const auto pos = queues.find(qid);
+    if (pos == queues.end())
+        return nullptr;
+    
+    return pos->second;
+    
+   //return queues.at(qid);
+}

source/shoh/src/threads/common/ThreadCommon.h

@@ -11,6 +11,7 @@
 #include "board.h"
 #include "FreeRTOS.h"
 #include <string>
+#include <map>
 #include "queue.h"
 #include "task.h"
 #include <assert.h>
@@ -19,6 +20,7 @@ namespace ThreadCommon
 {
     typedef enum EventType
     {
+        Null,
         Rotary,
         Temperature,
         Manager
@@ -61,12 +63,46 @@ namespace ThreadCommon
         private:
     };
 
+    class QueueManager
+    {
+        public:
+            enum Queue_id {
+                master_event_all,
+                relay_event_master,
+                manager_event_master,
+                ui_event_manager
+            };
+            QueueManager();
+            ~QueueManager() = default;
+            bool createQueue(size_t queue_length, size_t item_size, Queue_id qid);
+            QueueHandle_t getQueue(Queue_id qid);
+            template<class T> bool send(Queue_id qid, T* data, TickType_t timeout){
+            	QueueHandle_t q = this->getQueue(qid);
+                BaseType_t qCheck = xQueueSend(q,
+                                               static_cast<void*>(data),
+                                               timeout);
+                return (qCheck == pdTRUE);
+            }
+            template<class T> bool receive(Queue_id qid, T* data, TickType_t timeout){
+            	QueueHandle_t q = this->getQueue(qid);
+                BaseType_t qCheck = xQueueReceive(q,
+                                                  static_cast<void*>(data),
+                                                  timeout);
+                return (qCheck == pdTRUE);
+            }
+
+        private:
+            std::map <Queue_id, QueueHandle_t> queues;
+    };
+
     /* global variables */
     /* 'receiver'_'what'_'sender'_q */
+    /*
     extern QueueHandle_t master_event_all_q;
     extern QueueHandle_t relay_event_master_q;
     extern QueueHandle_t manager_event_master_q;
     extern QueueHandle_t ui_event_manager_q;
+    */
 }
 
 #endif /*__THREAD_COMMON_H_*/

source/shoh/src/threads/master/Master.cpp

@@ -7,22 +7,25 @@
 
 #include "Master.h"
 
+Master::Master(ThreadCommon::QueueManager* qm) : _qm(qm)
+{
+
+}
+
 void Master::taskFunction() {
+	ThreadCommon::Event data(ThreadCommon::Null, 0);
 	int led = 0;
 	bool LedState = true;
 	for (;;) {
-		Board_LED_Set(led, LedState);
+		_qm->receive<ThreadCommon::Event>(ThreadCommon::QueueManager::master_event_all, &data, portMAX_DELAY);
-		LedState = (bool) !LedState;
+		if(data.getData() == 1 && data.getType() == ThreadCommon::EventType::Rotary){
-		led++;
+			Board_LED_Set(led, LedState);
-		if(led > 2){
-			led = 0;
 		}
-		vTaskDelay(1000);
 	}
 }
 
 
 void master_thread(void* pvParams) {
-	Master m;
+	Master m(static_cast<ThreadCommon::QueueManager*>(pvParams));
 	m.taskFunction();
-}
+}

source/shoh/src/threads/master/Master.h

@@ -16,7 +16,7 @@
 
 class Master {
 public:
-	Master(){};
+	Master(ThreadCommon::QueueManager* qm);
 	virtual ~Master() = default;
 	void taskFunction();
 
@@ -24,6 +24,7 @@ public:
 	//Master& operator=(Master&&) noexcept = default;
 private:
 	ThreadCommon::Event* message;
+	ThreadCommon::QueueManager* _qm;
 };
 
 void master_thread(void* pvParams);