change the structure a bit

01-tasks/01-tasks-solutions/main-01.cpp

@@ -0,0 +1,17 @@
+#include <iostream>
+#include <thread>
+
+using namespace std;
+
+void mySimpleTask() {
+    using namespace std::chrono_literals;
+    while(true) {
+        cout << "Hello World" << endl;
+        this_thread::sleep_for(1000ms);
+    }
+}
+
+int main() {
+    std::thread thread(mySimpleTask);
+    thread.join();
+}

01-tasks/01-tasks-solutions/main-02.cpp

@@ -0,0 +1,31 @@
+#include <iostream>
+#include <thread>
+
+using namespace std;
+
+class MyExecutableObject {
+public:
+    MyExecutableObject(uint32_t delayMs): delayMs(delayMs) {}
+
+    static void executeTask(MyExecutableObject& self) {
+        while(true) {
+            self.performOperation();
+            this_thread::sleep_for(std::chrono::milliseconds(self.delayMs));
+        }
+    }
+
+    void performOperation() {
+        cout << "Hello World" << endl;
+    }
+private:
+    uint32_t delayMs;
+};
+
+int main() {
+    MyExecutableObject myExecutableObject(1000);
+    std::thread thread(
+        MyExecutableObject::executeTask,
+        std::reference_wrapper(myExecutableObject));
+    thread.join();
+    return 0;
+}

01-tasks/01-tasks-solutions/main-03.cpp

@@ -0,0 +1,77 @@
+#include <iostream>
+#include <thread>
+
+using namespace std;
+
+class MyExecutableObjectIF {
+public:
+    virtual ~MyExecutableObjectIF() = default;
+    virtual void performOperation() = 0;
+};
+
+class MyExecutableObject0: public MyExecutableObjectIF {
+public:
+    MyExecutableObject0() = default;
+
+    void performOperation() override {
+        cout << "Task 0" << endl;
+    }
+private:
+};
+
+class MyExecutableObject1: public MyExecutableObjectIF {
+public:
+    MyExecutableObject1() = default;
+
+    void performOperation() override {
+        cout << "Task 1" << endl;
+    }
+private:
+};
+
+class MyExecutableObject2: public MyExecutableObjectIF {
+public:
+    MyExecutableObject2() = default;
+
+    void performOperation() override {
+        cout << "Task 2" << endl;
+    }
+private:
+};
+
+class MyPeriodicTask {
+public:
+    MyPeriodicTask(MyExecutableObjectIF& executable, uint32_t taskFreqMs)
+        : executable(executable), taskFreqMs(taskFreqMs) {}
+
+    std::thread start() {
+        return std::thread(
+            MyPeriodicTask::executeTask,
+            std::reference_wrapper(*this));
+    }
+private:
+    static void executeTask(MyPeriodicTask& self) {
+        while(true) {
+            self.executable.performOperation();
+            this_thread::sleep_for(std::chrono::milliseconds(self.taskFreqMs));
+        }
+    }
+    MyExecutableObjectIF& executable;
+    uint32_t taskFreqMs;
+};
+
+int main() {
+    MyExecutableObject0 myExecutableObject0;
+    MyExecutableObject1 myExecutableObject1;
+    MyExecutableObject2 myExecutableObject2;
+    MyPeriodicTask task0(myExecutableObject0, 1000);
+    MyPeriodicTask task1(myExecutableObject1, 2000);
+    MyPeriodicTask task2(myExecutableObject2, 5000);
+    auto thread0 = task0.start();
+    auto thread1 = task1.start();
+    auto thread2 = task2.start();
+    thread0.join();
+    thread1.join();
+    thread2.join();
+    return 0;
+}

01-tasks/01-tasks-solutions/main-04.cpp

@@ -0,0 +1,85 @@
+#include <iostream>
+#include <thread>
+
+#include "fsfw/tasks/ExecutableObjectIF.h"
+#include "fsfw/tasks/PeriodicTaskIF.h"
+#include "fsfw/tasks/TaskFactory.h"
+
+using namespace std;
+
+class MyExecutableObjectIF {
+public:
+    virtual ~MyExecutableObjectIF() = default;
+    virtual void performOperation() = 0;
+};
+
+class MyExecutableObject0: public ExecutableObjectIF {
+public:
+    MyExecutableObject0() = default;
+
+    ReturnValue_t performOperation(uint8_t opCode) override {
+        cout << "Task 0" << endl;
+        return returnvalue::OK;
+    }
+private:
+};
+
+class MyExecutableObject1: public ExecutableObjectIF  {
+public:
+    MyExecutableObject1() = default;
+
+    ReturnValue_t performOperation(uint8_t opCode) override {
+        cout << "Task 1" << endl;
+        return returnvalue::OK;
+    }
+private:
+};
+
+class MyExecutableObject2: public ExecutableObjectIF  {
+public:
+    MyExecutableObject2() = default;
+
+    ReturnValue_t performOperation(uint8_t opCode) override {
+        cout << "Task 2" << endl;
+        return returnvalue::OK;
+    }
+private:
+};
+
+class MyPeriodicTask {
+public:
+    MyPeriodicTask(MyExecutableObjectIF& executable, uint32_t taskFreqMs)
+        : executable(executable), taskFreqMs(taskFreqMs) {}
+
+    std::thread start() {
+        return std::thread(
+            MyPeriodicTask::executeTask,
+            std::reference_wrapper(*this));
+    }
+private:
+    static void executeTask(MyPeriodicTask& self) {
+        while(true) {
+            self.executable.performOperation();
+            this_thread::sleep_for(std::chrono::milliseconds(self.taskFreqMs));
+        }
+    }
+    MyExecutableObjectIF& executable;
+    uint32_t taskFreqMs;
+};
+
+int main() {
+    MyExecutableObject0 myExecutableObject0;
+    MyExecutableObject1 myExecutableObject1;
+    MyExecutableObject2 myExecutableObject2;
+    auto* factory = TaskFactory::instance();
+    auto* periodicTask0 = factory->createPeriodicTask("TASK_0", 0, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.5, nullptr);
+    auto* periodicTask1 = factory->createPeriodicTask("TASK_1", 0, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, nullptr);
+    periodicTask0->addComponent(&myExecutableObject0);
+    periodicTask0->addComponent(&myExecutableObject1);
+    periodicTask1->addComponent(&myExecutableObject2);
+    periodicTask0->startTask();
+    periodicTask1->startTask();
+    while(true) {
+        this_thread::sleep_for(5000ms);
+    }
+}