new random to generate the bmp, only in main4

main4.cpp

@@ -6,28 +6,18 @@
 #include <windows.h>
 
 // === Parameters ===
-const int BPM_MIN = 50;
+//const int BPM_MIN = 50;
-const int BPM_MAX = 120;
+//const int BPM_MAX = 120;
-const int SAMPLE_INTERVAL_MS = 100; // Sampling every 10 ms
+const int SAMPLE_INTERVAL_MS = 1000; // Sampling every 10 ms
-const int THRESHOLD = 550;         // Threshold for heartbeat detection
+const int THRESHOLD_CARDIAC_ARREST = 2;         
-const int NOISE_LEVEL = 100;       // Simulated noise level
+//const int NOISE_LEVEL = 100;       // Simulated noise level
 
-// === Initialize random generator ===
-void initialiserRandom() {
-    srand(static_cast<unsigned int>(time(0)));
-}
 
-// === Simulate heart signal from sensor ===
+// === Initialize random generator ===// === Simulate heart signal from sensor ===
-int simulerSignalCardiaque() {
+int generateRandomHeartRate() {
-    static int t = 0;
+    //int bpm = 30 + rand() % 111; // génère un BPM entre 30 et 140
-    t++;
+    int bpm = rand() % 141;  //  génère un BPM entre 0 et 140
-
+    return bpm;
-    // Simulate a peak every ~800 ms (≈75 BPM)
-    if (t % 80 == 0) {
-        return 700 + rand() % 50; // Simulated peak
-    } else if (t % 10==0){
-        return 300 + rand() % NOISE_LEVEL; // Background noise
-    } 
 }
 
 // === Simulate buzzer activation ===
@@ -47,46 +37,55 @@ void envoyerMessageBluetooth(bool urgence) {
 
 // === Main program ===
 int main() {
-    initialiserRandom();
 
     bool battementDetecte = false;
     auto dernierBattement = std::chrono::steady_clock::now();
 
     std::cout << " Demarrage de la simulation du capteur cardiaque...\n";
+    int i=0;
+    int lastBPM;
 
     while (true) {
-        int signal = simulerSignalCardiaque();
+        //int signal = simulerSignalCardiaque();
         //std::cout << "Signal: " << signal << std::endl; // verify the signal detected
 
         // Détection de battement
-        if (signal > THRESHOLD && !battementDetecte) {
+        if (!battementDetecte) { //signal > THRESHOLD &&
             auto maintenant = std::chrono::steady_clock::now();
             auto intervalle = std::chrono::duration_cast<std::chrono::milliseconds>(maintenant - dernierBattement).count();
+            
+            int bpm = generateRandomHeartRate();
+            std::cout << " BPM mesure : " << bpm;
 
-            if (intervalle > 300) { // BPM > 200 => ignore
+            if (bpm < 55 && bpm > 40){
-                int bpm = 60000 / intervalle;
+                std::cout << " [BRADYCARDIA]"  << std::endl;
-                std::cout << " BPM mesure : " << bpm;
+                activerVibreur();
-
+            } else if(bpm < 140 && bpm > 110) {
-                bool anomalie = (bpm < BPM_MIN || bpm > BPM_MAX);
+                std::cout << " [TACHYCARDIA]"  << std::endl;
-                if (anomalie) {
+                activerVibreur();
-                    std::cout << " [ANOMALIE]";
+            }else if(bpm < 110 && bpm > 55){
+                std::cout << " [NORMAL]" << std::endl;
+                envoyerMessageBluetooth(false);
+            } else if (bpm < 40){
+                if (i>THRESHOLD_CARDIAC_ARREST && lastBPM < 40){
+                    i=0;
+                    std::cout << " [CARDIAC ARREST]" << std::endl;
                     activerBuzzer();
                     activerVibreur();
                     envoyerMessageBluetooth(true);
-                } else {
+                }else{
-                    envoyerMessageBluetooth(false);
+                    i+=1;
-                }
+                }  
-                std::cout << std::endl;
+            }   
-
+            std::cout << std::endl;
-                dernierBattement = maintenant;
-            }
 
+            dernierBattement = maintenant;
             battementDetecte = true;
-        }
+            lastBPM =bpm;
+            std::cout << lastBPM << std::endl;
 
-        // Prêt pour détecter le prochain battement
+        }else {
-        if (signal < THRESHOLD) {
+            battementDetecte = false;// Prêt pour détecter le prochain battement
-            battementDetecte = false;
         }
 
         Sleep(SAMPLE_INTERVAL_MS);  // expects milliseconds

test.cpp

@@ -1,9 +1,70 @@
 #include <iostream>
-#include <thread>
+#include <vector>
 #include <chrono>
+#include <random>
 
-int main() {
+// État du rythme cardiaque
-    std::cout << "Sleeping..." << std::endl;
+enum class HeartRateState {
-    std::this_thread::sleep_for(std::chrono::seconds(1));
+    NORMAL,
-    std::cout << "Awake!" << std::endl;
+    BRADYCARDIA,
+    TACHYCARDIA
+};
+
+// Fonction pour générer un signal de battement cardiaque
+std::vector<float> generateHeartbeatSignal(HeartRateState state, int durationSeconds = 10, int sampleRate = 1000) {
+    int bpm;
+    switch (state) {
+        case HeartRateState::BRADYCARDIA:
+            bpm = 40 + rand() % 15; // 40-55 BPM
+            break;
+        case HeartRateState::TACHYCARDIA:
+            bpm = 110 + rand() % 30; // 110-140 BPM
+            break;
+        default:
+            bpm = 60 + rand() % 40; // 60-100 BPM
+            break;
+    }
+
+    int totalSamples = durationSeconds * sampleRate;
+    int samplesPerBeat = (60.0 / bpm) * sampleRate;
+
+    std::vector<float> signal(totalSamples, 0.0f);
+
+    for (int i = 0; i < totalSamples; i += samplesPerBeat) {
+        if (i < totalSamples) signal[i] = 1.0f;       // Pic R
+        if (i + 1 < totalSamples) signal[i + 1] = 0.5f;
+        if (i + 2 < totalSamples) signal[i + 2] = 0.2f;
+    }
+
+    return signal;
 }
+
+// Pause active sans utiliser thread
+void waitMilliseconds(int ms) {
+    auto start = std::chrono::high_resolution_clock::now();
+    while (std::chrono::duration_cast<std::chrono::milliseconds>(
+               std::chrono::high_resolution_clock::now() - start).count() < ms) {
+        // boucle vide
+    }
+}
+
+// Affichage du signal
+void printSignal(const std::vector<float>& signal, int sampleRate) {
+    for (size_t i = 0; i < signal.size(); ++i) {
+        std::cout << signal[i] << "\n";
+        waitMilliseconds(1000 / sampleRate);
+    }
+}
+
+// ----------- FONCTION PRINCIPALE ------------
+int main() {
+    std::cout << "Simulation d’un signal de battement cardiaque\n";
+
+    // Tu peux changer ici : NORMAL / BRADYCARDIA / TACHYCARDIA
+    HeartRateState state = HeartRateState::TACHYCARDIA;
+
+    std::vector<float> signal = generateHeartbeatSignal(state, 5, 100); // 5 secondes, 100 Hz
+    printSignal(signal, 100);
+
+    return 0;
+}