functional and commented

sensor_network.cpp

@@ -0,0 +1,138 @@
+#include "sensor_network.h"
+#include <iostream>
+#include <random>
+#include <chrono>
+
+/**
+ * Startet alle Threads des Netzwerks
+ * @param num_sensors Anzahl der Sensor-Threads
+ * @param num_analysers Anzahl der Analyse-Threads
+ */
+template <size_t N>
+void SensorNetwork<N>::start(size_t num_sensors, size_t num_analysers) {
+    running = true;
+
+    // Starte Sensor-Threads
+    for(size_t i = 0; i < num_sensors; ++i) {
+        sensors.emplace_back([this, i] {
+            sensor_thread(i);
+        });
+    }
+
+    // Starte Analyse-Threads
+    for(size_t i = 0; i < num_analysers; ++i) {
+        analysers.emplace_back([this, i] {
+            analyser_thread(i);
+        });
+    }
+
+    // Starte Controller-Thread
+    controller = std::thread([this] {
+        controller_thread();
+    });
+}
+
+/**
+ * Stoppt alle Threads und wartet auf Beendigung
+ */
+template <size_t N>
+void SensorNetwork<N>::stop() {
+    running = false;
+
+    // Warte auf Thread-Ende
+    for(auto& t : sensors) {
+        if (t.joinable()) t.join();
+    }
+    for(auto& t : analysers) {
+        if (t.joinable()) t.join();
+    }
+    if (controller.joinable()) {
+        controller.join();
+    }
+}
+
+/**
+ * Thread-Funktion für Sensoren (Producer)
+ * @param id Eindeutige ID des Sensors
+ *
+ * Funktionsweise:
+ * 1. Generiert zufällige Messwerte
+ * 2. Wartet zufällige Zeit (Messintervall)
+ * 3. Schreibt Daten in Ringpuffer
+ */
+template <size_t N>
+void SensorNetwork<N>::sensor_thread(int id) {
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::uniform_int_distribution<> data_gen(0, 100);  // Messwerte 0-100
+    std::uniform_int_distribution<> sleep_gen(100, 500); // Intervall 100-500ms
+
+    while(running) {
+        // Simuliere Messintervall
+        std::this_thread::sleep_for(
+            std::chrono::milliseconds(sleep_gen(gen))
+        );
+
+        // Generiere und schreibe Messwert
+        int value = data_gen(gen);
+        buffer.push(value);
+
+        std::cout << "Sensor " << id << " produced: " << value << "\n";
+    }
+}
+
+/**
+ * Thread-Funktion für Analyse-Module (Consumer)
+ * @param id Eindeutige ID des Moduls
+ *
+ * Funktionsweise:
+ * 1. Liest Daten aus Ringpuffer (blockierend)
+ * 2. Liest aktuelles Analysemodell
+ * 3. Verarbeitet Daten (hier nur Ausgabe)
+ */
+template <size_t N>
+void SensorNetwork<N>::analyser_thread(int id) {
+    while(running) {
+        // Blockierendes Lesen aus Puffer
+        int data = buffer.pop();
+
+        // Lesender Zugriff auf Analysemodell
+        int model_value = model.read();
+
+        std::cout << "Analyser " << id << " processed: " << data
+                  << " | Model: " << model_value << "\n";
+    }
+}
+
+/**
+ * Thread-Funktion für System-Controller (Writer)
+ *
+ * Funktionsweise:
+ * 1. Wartet zufällige Zeit zwischen Updates
+ * 2. Schreibt neuen Wert ins Analysemodell
+ */
+template <size_t N>
+void SensorNetwork<N>::controller_thread() {
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::uniform_int_distribution<> update_gen(0, 100); // Modellwerte
+    std::uniform_int_distribution<> sleep_gen(500, 2000); // Update-Intervall
+
+    while(running) {
+        // Warte bis zum nächsten Update
+        std::this_thread::sleep_for(
+            std::chrono::milliseconds(sleep_gen(gen))
+        );
+
+        // Aktualisiere Analysemodell
+        int new_value = update_gen(gen);
+        model.write(new_value);
+
+        std::cout << "Controller updated model to: " << new_value << "\n";
+    }
+}
+
+// Explizite Instanziierung für gängige Puffergrößen
+template class SensorNetwork<8>;
+template class SensorNetwork<16>;
+template class SensorNetwork<32>;