BS_Praktikum4/sensor_network.cpp

#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>;