added comments

sensor_network.cpp

@@ -3,51 +3,77 @@
 #include <random>
 #include <chrono>
 
+/**
+ * Startet das Sensornetzwerk
+ * @param sensors Anzahl der Sensor-Threads
+ * @param analysers Anzahl der Analyse-Threads
+ */
 template <size_t N>
 void SensorNetwork<N>::start(size_t sensors, size_t analysers) {
     running = true;
     
-    // Sensor threads
+    // Sensor-Threads erstellen
     for (size_t i = 0; i < sensors; ++i) {
         threads.emplace_back([this] {
             std::mt19937 gen(std::random_device{}());
             std::uniform_int_distribution<> dist(0, 100);
+            
             while (running) {
-                std::this_thread::sleep_for(std::chrono::milliseconds(100 + gen() % 400));
+                // Zufälliges Intervall (100-500ms)
+                std::this_thread::sleep_for(
+                    std::chrono::milliseconds(100 + gen() % 400));
+                
+                // Messwert generieren und speichern
                 buffer.push(dist(gen));
             }
         });
     }
 
-    // Analyser threads
+    // Analyse-Threads erstellen
     for (size_t i = 0; i < analysers; ++i) {
         threads.emplace_back([this] {
             while (running) {
+                // Daten aus Puffer lesen
                 int data = buffer.pop();
+                
+                // Analysemodell lesen
                 int model_val = model.read();
-                std::cout << "Data: " << data << " Model: " << model_val << "\n";
+                
+                // Ausgabe (könnte auch analysieren)
+                std::cout << "Data: " << data 
+                          << " Model: " << model_val << "\n";
             }
         });
     }
 
-    // Controller thread
+    // Controller-Thread erstellen
     threads.emplace_back([this] {
         std::mt19937 gen(std::random_device{}());
         while (running) {
-            std::this_thread::sleep_for(std::chrono::milliseconds(500 + gen() % 1500));
+            // Zufälliges Update-Intervall (500-2000ms)
+            std::this_thread::sleep_for(
+                std::chrono::milliseconds(500 + gen() % 1500));
+            
+            // Analysemodell aktualisieren
             model.write(gen() % 100);
         }
     });
 }
 
+/**
+ * Stoppt das Sensornetzwerk und wartet auf Threads
+ */
 template <size_t N>
 void SensorNetwork<N>::stop() {
-    running = false;
+    running = false;  // Signal zum Stoppen
+    
+    // Auf alle Threads warten
     for (auto& t : threads) {
         if (t.joinable()) t.join();
     }
 }
 
+// Explizite Instanziierungen für gängige Puffergrößen
 template class SensorNetwork<8>;
 template class SensorNetwork<16>;
 template class SensorNetwork<32>;